[INFO] crate radix-calc 1.0.3 is already in cache [INFO] extracting crate radix-calc 1.0.3 into work/ex/clippy-test-run/sources/stable/reg/radix-calc/1.0.3 [INFO] extracting crate radix-calc 1.0.3 into work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/reg/radix-calc/1.0.3 [INFO] validating manifest of radix-calc-1.0.3 on toolchain stable [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "read-manifest" "--manifest-path" "Cargo.toml"` [INFO] validating manifest of radix-calc-1.0.3 on toolchain stable+rustflags=-Dclippy::into_iter_on_array [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "read-manifest" "--manifest-path" "Cargo.toml"` [INFO] started frobbing radix-calc-1.0.3 [INFO] finished frobbing radix-calc-1.0.3 [INFO] frobbed toml for radix-calc-1.0.3 written to work/ex/clippy-test-run/sources/stable/reg/radix-calc/1.0.3/Cargo.toml [INFO] started frobbing radix-calc-1.0.3 [INFO] finished frobbing radix-calc-1.0.3 [INFO] frobbed toml for radix-calc-1.0.3 written to work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/reg/radix-calc/1.0.3/Cargo.toml [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"` [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"` [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "fetch" "--locked" "--manifest-path" "Cargo.toml"` [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "fetch" "--locked" "--manifest-path" "Cargo.toml"` [INFO] linting radix-calc-1.0.3 against stable for clippy-test-run [INFO] running `"docker" "create" "-v" "/mnt/big/crater/work/local/target-dirs/clippy-test-run/worker-3/stable:/opt/crater/target:rw,Z" "-v" "/mnt/big/crater/work/ex/clippy-test-run/sources/stable/reg/radix-calc/1.0.3:/opt/crater/workdir:ro,Z" "-v" "/mnt/big/crater/work/local/cargo-home:/opt/crater/cargo-home:ro,Z" "-v" "/mnt/big/crater/work/local/rustup-home:/opt/crater/rustup-home:ro,Z" "-e" "USER_ID=1000" "-e" "SOURCE_DIR=/opt/crater/workdir" "-e" "MAP_USER_ID=1000" "-e" "CARGO_TARGET_DIR=/opt/crater/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/crater/cargo-home" "-e" "RUSTUP_HOME=/opt/crater/rustup-home" "-w" "/opt/crater/workdir" "-m" "1536M" "--network" "none" "rustops/crates-build-env" "/opt/crater/cargo-home/bin/cargo" "+stable" "clippy" "--frozen" "--all" "--all-targets"` [INFO] [stdout] 2e85fb4447a274a6b9c6f4783549dcc7087c9fd22c8d407d466575eb59ed3b4f [INFO] running `"docker" "start" "-a" "2e85fb4447a274a6b9c6f4783549dcc7087c9fd22c8d407d466575eb59ed3b4f"` [INFO] [stderr] Compiling peg v0.5.7 [INFO] [stderr] Checking docopt v0.7.0 [INFO] [stderr] Compiling radix-calc v1.0.3 (/opt/crater/workdir) [INFO] [stderr] warning: literal with an empty format string [INFO] [stderr] --> src/main.rs:185:21 [INFO] [stderr] | [INFO] [stderr] 185 | "...", [INFO] [stderr] | ^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::print_literal)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#print_literal [INFO] [stderr] [INFO] [stderr] warning: literal with an empty format string [INFO] [stderr] --> src/main.rs:185:21 [INFO] [stderr] | [INFO] [stderr] 185 | "...", [INFO] [stderr] | ^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::print_literal)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#print_literal [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:54:60 [INFO] [stderr] | [INFO] [stderr] 54 | self . max_err_pos = pos ; self . expected . clear ( ) ; } if pos == self . [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::suspicious_else_formatting)] on by default [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:779 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1060 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1341 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1881 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2417 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:3208 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1622 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2160 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2696 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2951 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> tests/calc_grammar.rs:23:47 [INFO] [stderr] | [INFO] [stderr] 23 | assert_eq!(radix_calc::expr("123456"), Ok(123456)); [INFO] [stderr] | ^^^^^^ help: consider: `123_456` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unreadable_literal)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> tests/calc_grammar.rs:46:51 [INFO] [stderr] | [INFO] [stderr] 46 | assert_eq!(radix_calc::expr("0xdeadbeef"), Ok(0xdeadbeef)); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0xdead_beef` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: unnecessary parentheses around function argument [INFO] [stderr] --> tests/calc_grammar.rs:89:48 [INFO] [stderr] | [INFO] [stderr] 89 | assert_eq!(radix_calc::expr("(5 * 4)"), Ok((5 * 4))); [INFO] [stderr] | ^^^^^^^ help: remove these parentheses [INFO] [stderr] | [INFO] [stderr] = note: #[warn(unused_parens)] on by default [INFO] [stderr] [INFO] [stderr] warning: Consider removing unnecessary double parentheses [INFO] [stderr] --> tests/calc_grammar.rs:89:48 [INFO] [stderr] | [INFO] [stderr] 89 | assert_eq!(radix_calc::expr("(5 * 4)"), Ok((5 * 4))); [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::double_parens)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#double_parens [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> tests/calc_grammar.rs:97:64 [INFO] [stderr] | [INFO] [stderr] 97 | assert_eq!(radix_calc::expr("0b11111111 | 0b00000000"), Ok(0b11111111)); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0b1111_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> tests/calc_grammar.rs:98:64 [INFO] [stderr] | [INFO] [stderr] 98 | assert_eq!(radix_calc::expr("0b00000000 | 0b00000000"), Ok(0b00000000)); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0b0000_0000` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> tests/calc_grammar.rs:99:64 [INFO] [stderr] | [INFO] [stderr] 99 | assert_eq!(radix_calc::expr("0b11111111 & 0b00000000"), Ok(0b00000000)); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0b0000_0000` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> tests/calc_grammar.rs:100:64 [INFO] [stderr] | [INFO] [stderr] 100 | assert_eq!(radix_calc::expr("0b00000000 & 0b00000000"), Ok(0b00000000)); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0b0000_0000` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> tests/calc_grammar.rs:101:64 [INFO] [stderr] | [INFO] [stderr] 101 | assert_eq!(radix_calc::expr("0b11111111 & 0b11111111"), Ok(0b11111111)); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0b1111_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> tests/calc_grammar.rs:102:64 [INFO] [stderr] | [INFO] [stderr] 102 | assert_eq!(radix_calc::expr("0b10101010 ^ 0b11110000"), Ok(0b10101010 ^ 0b11110000)); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0b1010_1010` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> tests/calc_grammar.rs:102:77 [INFO] [stderr] | [INFO] [stderr] 102 | assert_eq!(radix_calc::expr("0b10101010 ^ 0b11110000"), Ok(0b10101010 ^ 0b11110000)); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0b1111_0000` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:14:6 [INFO] [stderr] | [INFO] [stderr] 14 | ; if self . expected . len ( ) == 0 { write ! ( fmt , "EOF" ) ? ; } else if [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `self . expected.is_empty()` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::len_zero)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: You appear to be counting bytes the naive way [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:46:46 [INFO] [stderr] | [INFO] [stderr] 46 | let before = & input [ .. pos ] ; let line = before . as_bytes ( ) . iter ( [INFO] [stderr] | ______________________________________________^ [INFO] [stderr] 47 | | ) . filter ( | && c | c == b'\n' ) . count ( ) + 1 ; let col = before . chars [INFO] [stderr] | |_______________________________________________^ help: Consider using the bytecount crate: `bytecount::count(before . as_bytes ( ), b'\n')` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::naive_bytecount)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#naive_bytecount [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:59:977 [INFO] [stderr] | [INFO] [stderr] 59 | fn __parse_dec_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match { let __seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "_" ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unit_arg)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 59 | fn __parse_dec_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match { let __seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => slice_eq ( __input , __state , __pos , "_" ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:63:870 [INFO] [stderr] | [INFO] [stderr] 63 | fn __parse_hex_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 63 | fn __parse_hex_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( () ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:63:915 [INFO] [stderr] | [INFO] [stderr] 63 | fn __parse_hex_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!__repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:67:826 [INFO] [stderr] | [INFO] [stderr] 67 | fn __parse_bin_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0b" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' | '1' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[01_]" ) , } } else { __state . mark_failure ( __pos , "[01_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 67 | fn __parse_bin_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0b" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' | '1' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[01_]" ) , } } else { __state . mark_failure ( __pos , "[01_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( () ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:67:871 [INFO] [stderr] | [INFO] [stderr] 67 | fn __parse_bin_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0b" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' | '1' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[01_]" ) , } } else { __state . mark_failure ( __pos , "[01_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!__repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:71:830 [INFO] [stderr] | [INFO] [stderr] 71 | fn __parse_oct_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0o" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '7' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-7_]" ) , } } else { __state . mark_failure ( __pos , "[0-7_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 71 | fn __parse_oct_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0o" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '7' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-7_]" ) , } } else { __state . mark_failure ( __pos , "[0-7_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( () ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:71:875 [INFO] [stderr] | [INFO] [stderr] 71 | fn __parse_oct_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0o" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '7' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-7_]" ) , } } else { __state . mark_failure ( __pos , "[0-7_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!__repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 31 [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:187 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::cyclomatic_complexity)] on by default [INFO] [stderr] = help: you could split it up into multiple smaller functions [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cyclomatic_complexity [INFO] [stderr] [INFO] [stderr] warning: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:93:2 [INFO] [stderr] | [INFO] [stderr] 93 | pub fn expr < 'input > ( __input : & 'input str ) -> ParseResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_expr ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_lifetimes)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:93:161 [INFO] [stderr] | [INFO] [stderr] 93 | pub fn expr < 'input > ( __input : & 'input str ) -> ParseResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_expr ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `if let Matched ( __pos , __value ) = __parse_expr ( __input , & mut __state , 0 ) { if __pos == __input . len ( ) { return Ok ( __value ) } }` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::single_match)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] [INFO] [stderr] warning: the operation is ineffective. Consider reducing it to `0` [INFO] [stderr] --> tests/calc_grammar.rs:55:46 [INFO] [stderr] | [INFO] [stderr] 55 | assert_eq!(radix_calc::expr("0 + 0"), Ok(0 + 0)); [INFO] [stderr] | ^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::identity_op)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#identity_op [INFO] [stderr] [INFO] [stderr] warning: the operation is ineffective. Consider reducing it to `0` [INFO] [stderr] --> tests/calc_grammar.rs:55:46 [INFO] [stderr] | [INFO] [stderr] 55 | assert_eq!(radix_calc::expr("0 + 0"), Ok(0 + 0)); [INFO] [stderr] | ^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#identity_op [INFO] [stderr] [INFO] [stderr] warning: the operation is ineffective. Consider reducing it to `0` [INFO] [stderr] --> tests/calc_grammar.rs:56:45 [INFO] [stderr] | [INFO] [stderr] 56 | assert_eq!(radix_calc::expr("0+ 0"), Ok(0 + 0)); [INFO] [stderr] | ^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#identity_op [INFO] [stderr] [INFO] [stderr] warning: the operation is ineffective. Consider reducing it to `0` [INFO] [stderr] --> tests/calc_grammar.rs:57:45 [INFO] [stderr] | [INFO] [stderr] 57 | assert_eq!(radix_calc::expr("0 +0"), Ok(0 + 0)); [INFO] [stderr] | ^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#identity_op [INFO] [stderr] [INFO] [stderr] warning: the operation is ineffective. Consider reducing it to `0` [INFO] [stderr] --> tests/calc_grammar.rs:58:44 [INFO] [stderr] | [INFO] [stderr] 58 | assert_eq!(radix_calc::expr("0+0"), Ok(0 + 0)); [INFO] [stderr] | ^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#identity_op [INFO] [stderr] [INFO] [stderr] warning: Constants have by default a `'static` lifetime [INFO] [stderr] --> src/main.rs:10:15 [INFO] [stderr] | [INFO] [stderr] 10 | const USAGE: &'static str = concat!(" [INFO] [stderr] | -^^^^^^^---- help: consider removing `'static`: `&str` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::const_static_lifetime)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#const_static_lifetime [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:54:60 [INFO] [stderr] | [INFO] [stderr] 54 | self . max_err_pos = pos ; self . expected . clear ( ) ; } if pos == self . [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::suspicious_else_formatting)] on by default [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:779 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1060 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1341 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1881 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2417 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:3208 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1622 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2160 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2696 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2951 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: Constants have by default a `'static` lifetime [INFO] [stderr] --> src/main.rs:10:15 [INFO] [stderr] | [INFO] [stderr] 10 | const USAGE: &'static str = concat!(" [INFO] [stderr] | -^^^^^^^---- help: consider removing `'static`: `&str` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::const_static_lifetime)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#const_static_lifetime [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:54:60 [INFO] [stderr] | [INFO] [stderr] 54 | self . max_err_pos = pos ; self . expected . clear ( ) ; } if pos == self . [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::suspicious_else_formatting)] on by default [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:779 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1060 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1341 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1881 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2417 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:3208 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:1622 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2160 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2696 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:2951 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: to remove this lint, add the missing `else` or add a new line before the second `if` [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:81:34 [INFO] [stderr] | [INFO] [stderr] 81 | assert_eq!(to_pretty_dec(123456), "123_456"); [INFO] [stderr] | ^^^^^^ help: consider: `123_456` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unreadable_literal)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:82:34 [INFO] [stderr] | [INFO] [stderr] 82 | assert_eq!(to_pretty_dec(1234567), "1_234_567"); [INFO] [stderr] | ^^^^^^^ help: consider: `1_234_567` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:92:34 [INFO] [stderr] | [INFO] [stderr] 92 | assert_eq!(to_pretty_hex(0x123456), "0x12_3456"); [INFO] [stderr] | ^^^^^^^^ help: consider: `0x0012_3456` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:93:34 [INFO] [stderr] | [INFO] [stderr] 93 | assert_eq!(to_pretty_hex(0x1234567), "0x123_4567"); [INFO] [stderr] | ^^^^^^^^^ help: consider: `0x0123_4567` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:94:34 [INFO] [stderr] | [INFO] [stderr] 94 | assert_eq!(to_pretty_hex(0x12345678), "0x1234_5678"); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0x1234_5678` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:95:34 [INFO] [stderr] | [INFO] [stderr] 95 | assert_eq!(to_pretty_hex(0x123456789), "0x1_2345_6789"); [INFO] [stderr] | ^^^^^^^^^^^ help: consider: `0x0001_2345_6789` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:105:34 [INFO] [stderr] | [INFO] [stderr] 105 | assert_eq!(to_pretty_oct(0o123456), "0o123_456"); [INFO] [stderr] | ^^^^^^^^ help: consider: `0o123_456` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:106:34 [INFO] [stderr] | [INFO] [stderr] 106 | assert_eq!(to_pretty_oct(0o1234567), "0o1_234_567"); [INFO] [stderr] | ^^^^^^^^^ help: consider: `0o1_234_567` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:107:34 [INFO] [stderr] | [INFO] [stderr] 107 | assert_eq!(to_pretty_oct(0o12345670), "0o12_345_670"); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0o12_345_670` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:108:34 [INFO] [stderr] | [INFO] [stderr] 108 | assert_eq!(to_pretty_oct(0o123456701), "0o123_456_701"); [INFO] [stderr] | ^^^^^^^^^^^ help: consider: `0o123_456_701` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:118:34 [INFO] [stderr] | [INFO] [stderr] 118 | assert_eq!(to_pretty_bin(0b111111), "0b111111"); [INFO] [stderr] | ^^^^^^^^ help: consider: `0b11_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:119:34 [INFO] [stderr] | [INFO] [stderr] 119 | assert_eq!(to_pretty_bin(0b1111111), "0b1111111"); [INFO] [stderr] | ^^^^^^^^^ help: consider: `0b111_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> src/main.rs:120:34 [INFO] [stderr] | [INFO] [stderr] 120 | assert_eq!(to_pretty_bin(0b11111111), "0b11111111"); [INFO] [stderr] | ^^^^^^^^^^ help: consider: `0b1111_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: digit groups should be smaller [INFO] [stderr] --> src/main.rs:121:34 [INFO] [stderr] | [INFO] [stderr] 121 | assert_eq!(to_pretty_bin(0b1_11111111), "0b1_11111111"); [INFO] [stderr] | ^^^^^^^^^^^^ help: consider: `0b1_1111_1111` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::large_digit_groups)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups [INFO] [stderr] [INFO] [stderr] warning: digit groups should be smaller [INFO] [stderr] --> src/main.rs:122:34 [INFO] [stderr] | [INFO] [stderr] 122 | assert_eq!(to_pretty_bin(0b11_11111111), "0b11_11111111"); [INFO] [stderr] | ^^^^^^^^^^^^^ help: consider: `0b11_1111_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups [INFO] [stderr] [INFO] [stderr] warning: digit groups should be smaller [INFO] [stderr] --> src/main.rs:123:34 [INFO] [stderr] | [INFO] [stderr] 123 | assert_eq!(to_pretty_bin(0b111_11111111), "0b111_11111111"); [INFO] [stderr] | ^^^^^^^^^^^^^^ help: consider: `0b111_1111_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups [INFO] [stderr] [INFO] [stderr] warning: digit groups should be smaller [INFO] [stderr] --> src/main.rs:124:34 [INFO] [stderr] | [INFO] [stderr] 124 | assert_eq!(to_pretty_bin(0b1111_11111111), "0b1111_11111111"); [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: consider: `0b1111_1111_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups [INFO] [stderr] [INFO] [stderr] warning: digit groups should be smaller [INFO] [stderr] --> src/main.rs:125:34 [INFO] [stderr] | [INFO] [stderr] 125 | assert_eq!(to_pretty_bin(0b11111111_11111111), "0b11111111_11111111"); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: consider: `0b1111_1111_1111_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups [INFO] [stderr] [INFO] [stderr] warning: digit groups should be smaller [INFO] [stderr] --> src/main.rs:126:34 [INFO] [stderr] | [INFO] [stderr] 126 | assert_eq!(to_pretty_bin(0b1_11111111_11111111), "0b1_11111111_11111111"); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: consider: `0b1_1111_1111_1111_1111` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:14:6 [INFO] [stderr] | [INFO] [stderr] 14 | ; if self . expected . len ( ) == 0 { write ! ( fmt , "EOF" ) ? ; } else if [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `self . expected.is_empty()` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::len_zero)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: You appear to be counting bytes the naive way [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:46:46 [INFO] [stderr] | [INFO] [stderr] 46 | let before = & input [ .. pos ] ; let line = before . as_bytes ( ) . iter ( [INFO] [stderr] | ______________________________________________^ [INFO] [stderr] 47 | | ) . filter ( | && c | c == b'\n' ) . count ( ) + 1 ; let col = before . chars [INFO] [stderr] | |_______________________________________________^ help: Consider using the bytecount crate: `bytecount::count(before . as_bytes ( ), b'\n')` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::naive_bytecount)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#naive_bytecount [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:59:977 [INFO] [stderr] | [INFO] [stderr] 59 | fn __parse_dec_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match { let __seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "_" ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unit_arg)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 59 | fn __parse_dec_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match { let __seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => slice_eq ( __input , __state , __pos , "_" ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:63:870 [INFO] [stderr] | [INFO] [stderr] 63 | fn __parse_hex_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 63 | fn __parse_hex_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( () ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:63:915 [INFO] [stderr] | [INFO] [stderr] 63 | fn __parse_hex_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!__repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:67:826 [INFO] [stderr] | [INFO] [stderr] 67 | fn __parse_bin_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0b" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' | '1' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[01_]" ) , } } else { __state . mark_failure ( __pos , "[01_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 67 | fn __parse_bin_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0b" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' | '1' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[01_]" ) , } } else { __state . mark_failure ( __pos , "[01_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( () ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:67:871 [INFO] [stderr] | [INFO] [stderr] 67 | fn __parse_bin_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0b" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' | '1' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[01_]" ) , } } else { __state . mark_failure ( __pos , "[01_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!__repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:71:830 [INFO] [stderr] | [INFO] [stderr] 71 | fn __parse_oct_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0o" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '7' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-7_]" ) , } } else { __state . mark_failure ( __pos , "[0-7_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 71 | fn __parse_oct_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0o" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '7' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-7_]" ) , } } else { __state . mark_failure ( __pos , "[0-7_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( () ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:71:875 [INFO] [stderr] | [INFO] [stderr] 71 | fn __parse_oct_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0o" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '7' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-7_]" ) , } } else { __state . mark_failure ( __pos , "[0-7_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!__repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 31 [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:187 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::cyclomatic_complexity)] on by default [INFO] [stderr] = help: you could split it up into multiple smaller functions [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cyclomatic_complexity [INFO] [stderr] [INFO] [stderr] warning: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:93:2 [INFO] [stderr] | [INFO] [stderr] 93 | pub fn expr < 'input > ( __input : & 'input str ) -> ParseResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_expr ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_lifetimes)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:93:161 [INFO] [stderr] | [INFO] [stderr] 93 | pub fn expr < 'input > ( __input : & 'input str ) -> ParseResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_expr ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `if let Matched ( __pos , __value ) = __parse_expr ( __input , & mut __state , 0 ) { if __pos == __input . len ( ) { return Ok ( __value ) } }` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::single_match)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:14:6 [INFO] [stderr] | [INFO] [stderr] 14 | ; if self . expected . len ( ) == 0 { write ! ( fmt , "EOF" ) ? ; } else if [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `self . expected.is_empty()` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::len_zero)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: You appear to be counting bytes the naive way [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:46:46 [INFO] [stderr] | [INFO] [stderr] 46 | let before = & input [ .. pos ] ; let line = before . as_bytes ( ) . iter ( [INFO] [stderr] | ______________________________________________^ [INFO] [stderr] 47 | | ) . filter ( | && c | c == b'\n' ) . count ( ) + 1 ; let col = before . chars [INFO] [stderr] | |_______________________________________________^ help: Consider using the bytecount crate: `bytecount::count(before . as_bytes ( ), b'\n')` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::naive_bytecount)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#naive_bytecount [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:59:977 [INFO] [stderr] | [INFO] [stderr] 59 | fn __parse_dec_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match { let __seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "_" ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unit_arg)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 59 | fn __parse_dec_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match { let __seq_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let __step_res = { let __choice_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => slice_eq ( __input , __state , __pos , "_" ) } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:63:870 [INFO] [stderr] | [INFO] [stderr] 63 | fn __parse_hex_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 63 | fn __parse_hex_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( () ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:63:915 [INFO] [stderr] | [INFO] [stderr] 63 | fn __parse_hex_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!__repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:67:826 [INFO] [stderr] | [INFO] [stderr] 67 | fn __parse_bin_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0b" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' | '1' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[01_]" ) , } } else { __state . mark_failure ( __pos , "[01_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 67 | fn __parse_bin_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0b" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' | '1' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[01_]" ) , } } else { __state . mark_failure ( __pos , "[01_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( () ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:67:871 [INFO] [stderr] | [INFO] [stderr] 67 | fn __parse_bin_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0b" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' | '1' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[01_]" ) , } } else { __state . mark_failure ( __pos , "[01_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!__repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:71:830 [INFO] [stderr] | [INFO] [stderr] 71 | fn __parse_oct_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0o" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '7' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-7_]" ) , } } else { __state . mark_failure ( __pos , "[0-7_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 71 | fn __parse_oct_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0o" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '7' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-7_]" ) , } } else { __state . mark_failure ( __pos , "[0-7_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( () ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:71:875 [INFO] [stderr] | [INFO] [stderr] 71 | fn __parse_oct_lit < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = slice_eq ( __input , __state , __pos , "0o" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '7' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-7_]" ) , } } else { __state . mark_failure ( __pos , "[0-7_]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!__repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 31 [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:89:187 [INFO] [stderr] | [INFO] [stderr] 89 | fn __parse_infix_arith < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { if let Matched ( __pos , mut __infix_result ) = __parse_atom ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "|" ) { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x | y } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "^" ) { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x ^ y } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "&" ) { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x & y } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , ">>" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x >> y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "<<" ) { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x << y } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "+" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x + y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "-" ) { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x - y } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "*" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x * y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "/" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x / y } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "%" ) { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x % y } ; __repeat_pos = __pos ; continue ; } } } if 6i32 >= __min_prec { if let Matched ( __pos , _ ) = slice_eq ( __input , __state , __pos , "**" ) { if let Matched ( __pos , y ) = __infix_parse ( 7i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { x.pow(y as u32) } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::cyclomatic_complexity)] on by default [INFO] [stderr] = help: you could split it up into multiple smaller functions [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cyclomatic_complexity [INFO] [stderr] [INFO] [stderr] warning: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:93:2 [INFO] [stderr] | [INFO] [stderr] 93 | pub fn expr < 'input > ( __input : & 'input str ) -> ParseResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_expr ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_lifetimes)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> /opt/crater/target/debug/build/radix-calc-67a76a25220647c9/out/radix-calc.rs:93:161 [INFO] [stderr] | [INFO] [stderr] 93 | pub fn expr < 'input > ( __input : & 'input str ) -> ParseResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_expr ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `if let Matched ( __pos , __value ) = __parse_expr ( __input , & mut __state , 0 ) { if __pos == __input . len ( ) { return Ok ( __value ) } }` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::single_match)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] [INFO] [stderr] Finished dev [unoptimized + debuginfo] target(s) in 6.10s [INFO] running `"docker" "inspect" "2e85fb4447a274a6b9c6f4783549dcc7087c9fd22c8d407d466575eb59ed3b4f"` [INFO] running `"docker" "rm" "-f" "2e85fb4447a274a6b9c6f4783549dcc7087c9fd22c8d407d466575eb59ed3b4f"` [INFO] [stdout] 2e85fb4447a274a6b9c6f4783549dcc7087c9fd22c8d407d466575eb59ed3b4f