[INFO] updating cached repository jasonhansel/kineticvm [INFO] running `"git" "fetch" "--all"` [INFO] [stdout] Fetching origin [INFO] [stderr] From git://github.com/jasonhansel/kineticvm [INFO] [stderr] * branch HEAD -> FETCH_HEAD [INFO] running `"git" "clone" "work/cache/sources/gh/jasonhansel/kineticvm" "work/ex/clippy-test-run/sources/stable/gh/jasonhansel/kineticvm"` [INFO] [stderr] Cloning into 'work/ex/clippy-test-run/sources/stable/gh/jasonhansel/kineticvm'... [INFO] [stderr] done. [INFO] running `"git" "clone" "work/cache/sources/gh/jasonhansel/kineticvm" "work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/gh/jasonhansel/kineticvm"` [INFO] [stderr] Cloning into 'work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/gh/jasonhansel/kineticvm'... [INFO] [stderr] done. [INFO] running `"git" "rev-parse" "HEAD"` [INFO] [stdout] 733ad84b567f049d8f3c3d4f0ff5439e0eb9102e [INFO] sha for GitHub repo jasonhansel/kineticvm: 733ad84b567f049d8f3c3d4f0ff5439e0eb9102e [INFO] validating manifest of jasonhansel/kineticvm 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 jasonhansel/kineticvm 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 jasonhansel/kineticvm [INFO] finished frobbing jasonhansel/kineticvm [INFO] frobbed toml for jasonhansel/kineticvm written to work/ex/clippy-test-run/sources/stable/gh/jasonhansel/kineticvm/Cargo.toml [INFO] started frobbing jasonhansel/kineticvm [INFO] finished frobbing jasonhansel/kineticvm [INFO] frobbed toml for jasonhansel/kineticvm written to work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/gh/jasonhansel/kineticvm/Cargo.toml [INFO] crate jasonhansel/kineticvm has a lockfile. skipping [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 jasonhansel/kineticvm 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/gh/jasonhansel/kineticvm:/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] 33ef5d3e93acbd1221597dfa11b107427b494027c53f850cae91030a437dc9d0 [INFO] running `"docker" "start" "-a" "33ef5d3e93acbd1221597dfa11b107427b494027c53f850cae91030a437dc9d0"` [INFO] [stderr] Compiling quote v0.3.10 [INFO] [stderr] Compiling peg v0.4.0 [INFO] [stderr] Compiling kineticvm v0.0.1 (/opt/crater/workdir) [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/vm/vmstate.rs:18:4 [INFO] [stderr] | [INFO] [stderr] 18 | memory: memory [INFO] [stderr] | ^^^^^^^^^^^^^^ help: replace it with: `memory` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::redundant_field_names)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names [INFO] [stderr] [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/vm/mod.rs:19:3 [INFO] [stderr] | [INFO] [stderr] 19 | registers: registers, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: replace it with: `registers` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names [INFO] [stderr] [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/vm/mod.rs:20:3 [INFO] [stderr] | [INFO] [stderr] 20 | code: code [INFO] [stderr] | ^^^^^^^^^^ help: replace it with: `code` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names [INFO] [stderr] [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/vm/vmstate.rs:18:4 [INFO] [stderr] | [INFO] [stderr] 18 | memory: memory [INFO] [stderr] | ^^^^^^^^^^^^^^ help: replace it with: `memory` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::redundant_field_names)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names [INFO] [stderr] [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/vm/mod.rs:19:3 [INFO] [stderr] | [INFO] [stderr] 19 | registers: registers, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: replace it with: `registers` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names [INFO] [stderr] [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/vm/mod.rs:20:3 [INFO] [stderr] | [INFO] [stderr] 20 | code: code [INFO] [stderr] | ^^^^^^^^^^ help: replace it with: `code` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:34:3 [INFO] [stderr] | [INFO] [stderr] 34 | return Value::Ptr(p); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `Value::Ptr(p)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_return)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:57:2 [INFO] [stderr] | [INFO] [stderr] 57 | return 1 + size + (1 + (size >> 4)); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `1 + size + (1 + (size >> 4))` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:70:3 [INFO] [stderr] | [INFO] [stderr] 70 | return mem; [INFO] [stderr] | ^^^^^^^^^^^ help: remove `return` as shown: `mem` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:75:3 [INFO] [stderr] | [INFO] [stderr] 75 | return self.get(root, r) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `self.get(root, r)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:84:3 [INFO] [stderr] | [INFO] [stderr] 84 | return self.get_carefully(ptr, offset).unwrap() [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `self.get_carefully(ptr, offset).unwrap()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:115:3 [INFO] [stderr] | [INFO] [stderr] 115 | return MemorySize(obj_size); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `MemorySize(obj_size)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/vmstate.rs:38:5 [INFO] [stderr] | [INFO] [stderr] 38 | return Value::Int(result as i16); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `Value::Int(result as i16)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:54:3 [INFO] [stderr] | [INFO] [stderr] 54 | } return ( lineno , remaining + 1 ) ; } impl < 'input > ParseState < 'input > [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `( lineno , remaining + 1 )` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:59:60 [INFO] [stderr] | [INFO] [stderr] 59 | 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: unneeded return statement [INFO] [stderr] --> src/asm/mod.rs:38:2 [INFO] [stderr] | [INFO] [stderr] 38 | return labels; [INFO] [stderr] | ^^^^^^^^^^^^^^ help: remove `return` as shown: `labels` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/asm/mod.rs:51:2 [INFO] [stderr] | [INFO] [stderr] 51 | return registers; [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `registers` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:34:3 [INFO] [stderr] | [INFO] [stderr] 34 | return Value::Ptr(p); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `Value::Ptr(p)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_return)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:57:2 [INFO] [stderr] | [INFO] [stderr] 57 | return 1 + size + (1 + (size >> 4)); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `1 + size + (1 + (size >> 4))` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:70:3 [INFO] [stderr] | [INFO] [stderr] 70 | return mem; [INFO] [stderr] | ^^^^^^^^^^^ help: remove `return` as shown: `mem` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:75:3 [INFO] [stderr] | [INFO] [stderr] 75 | return self.get(root, r) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `self.get(root, r)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:84:3 [INFO] [stderr] | [INFO] [stderr] 84 | return self.get_carefully(ptr, offset).unwrap() [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `self.get_carefully(ptr, offset).unwrap()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/memory.rs:115:3 [INFO] [stderr] | [INFO] [stderr] 115 | return MemorySize(obj_size); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `MemorySize(obj_size)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/vm/vmstate.rs:38:5 [INFO] [stderr] | [INFO] [stderr] 38 | return Value::Int(result as i16); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `Value::Int(result as i16)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:54:3 [INFO] [stderr] | [INFO] [stderr] 54 | } return ( lineno , remaining + 1 ) ; } impl < 'input > ParseState < 'input > [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `( lineno , remaining + 1 )` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:59:60 [INFO] [stderr] | [INFO] [stderr] 59 | 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: unneeded return statement [INFO] [stderr] --> src/asm/mod.rs:38:2 [INFO] [stderr] | [INFO] [stderr] 38 | return labels; [INFO] [stderr] | ^^^^^^^^^^^^^^ help: remove `return` as shown: `labels` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/asm/mod.rs:51:2 [INFO] [stderr] | [INFO] [stderr] 51 | return registers; [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `registers` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unused import: `Read` [INFO] [stderr] --> src/test.rs:7:22 [INFO] [stderr] | [INFO] [stderr] 7 | use std::io::{Cursor,Read}; [INFO] [stderr] | ^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(unused_imports)] on by default [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/test.rs:16:2 [INFO] [stderr] | [INFO] [stderr] 16 | return String::from_utf8(output).unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `String::from_utf8(output).unwrap()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unused macro definition [INFO] [stderr] --> src/test.rs:42:1 [INFO] [stderr] | [INFO] [stderr] 42 | / macro_rules! bench_program { [INFO] [stderr] 43 | | ( $x:ident ) => { [INFO] [stderr] 44 | | [INFO] [stderr] 45 | | [INFO] [stderr] ... | [INFO] [stderr] 62 | | } [INFO] [stderr] 63 | | } [INFO] [stderr] | |_^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(unused_macros)] on by default [INFO] [stderr] [INFO] [stderr] warning: casting u8 to i16 may become silently lossy if types change [INFO] [stderr] --> src/vm/vmstate.rs:38:23 [INFO] [stderr] | [INFO] [stderr] 38 | return Value::Int(result as i16); [INFO] [stderr] | ^^^^^^^^^^^^^ help: try: `i16::from(result)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::cast_lossless)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/vm/mod.rs:16:25 [INFO] [stderr] | [INFO] [stderr] 16 | let registers = &words[1..(1+reg_count)]; [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: use: `1..=reg_count` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::range_plus_one)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:15:6 [INFO] [stderr] | [INFO] [stderr] 15 | ; if self . expected . len ( ) == 0 { try ! ( write ! ( fmt , "EOF" ) ) ; } [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: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:62:892 [INFO] [stderr] | [INFO] [stderr] 62 | fn parse_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_first_object ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , fo ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_object ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , o ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { if let Some(f) = fo { let mut v = vec![f]; v.extend_from_slice(&o); v } else { o } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } [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/kineticvm-75c47ee1789facb3/out/grammar.rs:62:1197 [INFO] [stderr] | [INFO] [stderr] 62 | fn parse_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_first_object ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , fo ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_object ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , o ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { if let Some(f) = fo { let mut v = vec![f]; v.extend_from_slice(&o); v } else { o } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } [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] 62 | fn parse_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_first_object ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , fo ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( () ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_object ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , o ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { if let Some(f) = fo { let mut v = vec![f]; v.extend_from_slice(&o); v } else { o } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:62:1240 [INFO] [stderr] | [INFO] [stderr] 62 | fn parse_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_first_object ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , fo ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_object ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , o ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { if let Some(f) = fo { let mut v = vec![f]; v.extend_from_slice(&o); v } else { o } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } [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: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:70:330 [INFO] [stderr] | [INFO] [stderr] 70 | fn parse_move_lines < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_move_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , l ) => { Matched ( __pos , { l } ) } Failed => Failed , } } } [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/kineticvm-75c47ee1789facb3/out/grammar.rs:70:635 [INFO] [stderr] | [INFO] [stderr] 70 | fn parse_move_lines < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_move_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , l ) => { Matched ( __pos , { l } ) } Failed => Failed , } } } [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] 70 | fn parse_move_lines < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( () ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_move_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , l ) => { Matched ( __pos , { l } ) } Failed => Failed , } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:70:678 [INFO] [stderr] | [INFO] [stderr] 70 | fn parse_move_lines < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_move_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , l ) => { Matched ( __pos , { l } ) } Failed => Failed , } } } [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/kineticvm-75c47ee1789facb3/out/grammar.rs:74:946 [INFO] [stderr] | [INFO] [stderr] 74 | fn parse_source_reg < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < RegisterR<'input> > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = { let str_start = __pos ; match { let seq_res = match slice_eq ( __input , __state , __pos , "-" ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match seq_res { Matched ( __pos , _ ) => { { 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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , imm ) => { Matched ( __pos , { RegisterR::Immed(imm.parse::().unwrap()) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::User(Ident::from_str(u)) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "%" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_system_reg ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::System(u) } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::Label(Ident::from_str(u)) } ) } Failed => Failed , } } } Failed => Failed , } } } } } } } } } [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] 74 | fn parse_source_reg < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < RegisterR<'input> > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = { let str_start = __pos ; match { let seq_res = match slice_eq ( __input , __state , __pos , "-" ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match seq_res { Matched ( __pos , _ ) => { { 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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( () ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , imm ) => { Matched ( __pos , { RegisterR::Immed(imm.parse::().unwrap()) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::User(Ident::from_str(u)) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "%" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_system_reg ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::System(u) } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::Label(Ident::from_str(u)) } ) } Failed => Failed , } } } Failed => Failed , } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:74:989 [INFO] [stderr] | [INFO] [stderr] 74 | fn parse_source_reg < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < RegisterR<'input> > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = { let str_start = __pos ; match { let seq_res = match slice_eq ( __input , __state , __pos , "-" ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match seq_res { Matched ( __pos , _ ) => { { 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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , imm ) => { Matched ( __pos , { RegisterR::Immed(imm.parse::().unwrap()) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::User(Ident::from_str(u)) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "%" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_system_reg ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::System(u) } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::Label(Ident::from_str(u)) } ) } Failed => Failed , } } } Failed => Failed , } } } } } } } } } [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 56 [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:78:2 [INFO] [stderr] | [INFO] [stderr] 78 | fn parse_system_reg < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Register > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "LHS" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::LHS } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "BIT_AND" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::BIT_AND } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "BIT_OR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::BIT_OR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "BIT_XOR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::BIT_XOR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "BIT_NOT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::BIT_NOT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "CODE_OBJECT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::CODE_OBJECT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "DIFF" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::DIFF } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "HALT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::HALT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MEM_OBJECT_SIZE" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MEM_OBJECT_SIZE } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MEM_OFFSET" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MEM_OFFSET } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MEM_PTR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MEM_PTR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "EQ" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::EQ } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MEM_VALUE" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MEM_VALUE } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "NOT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::NOT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "OUT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::OUT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "PC" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::PC } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "PRODUCT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::PRODUCT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "QUOTIENT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::QUOTIENT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "RHS" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::RHS } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SHIFT_AR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SHIFT_AR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SHIFT_LR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SHIFT_LR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SHIFT_L" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SHIFT_L } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SKIP_INSTR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SKIP_INSTR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SUM" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SUM } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MAX" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MAX } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MIN" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MIN } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "LINK" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::LINK } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , "IO_CHAR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::IO_CHAR } ) } Failed => Failed , } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } [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: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:80:739 [INFO] [stderr] | [INFO] [stderr] 80 | fn parse_ident < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < &'input str > { # ! [ allow ( non_snake_case , unused ) ] { 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 { 'a' ... 'z' | 'A' ... 'Z' | '_' | '-' | '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } } [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] 80 | fn parse_ident < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < &'input str > { # ! [ allow ( non_snake_case , unused ) ] { 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 { 'a' ... 'z' | 'A' ... 'Z' | '_' | '-' | '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( () ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:80:782 [INFO] [stderr] | [INFO] [stderr] 80 | fn parse_ident < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < &'input str > { # ! [ allow ( non_snake_case , unused ) ] { 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 { 'a' ... 'z' | 'A' ... 'Z' | '_' | '-' | '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } } [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/kineticvm-75c47ee1789facb3/out/grammar.rs:82:318 [INFO] [stderr] | [INFO] [stderr] 82 | fn parse_optional_comment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_white ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' => __state . mark_failure ( __pos , "[^\n]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^\n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } } Failed => Failed , } } } } } [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] 82 | fn parse_optional_comment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_white ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' => __state . mark_failure ( __pos , "[^\n]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^\n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } } Failed => Failed , } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:84:445 [INFO] [stderr] | [INFO] [stderr] 84 | fn parse_end_of_line < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "\n" ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' => __state . mark_failure ( __pos , "[^\n]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^\n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "\n" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } } } [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] 84 | fn parse_end_of_line < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "\n" ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' => __state . mark_failure ( __pos , "[^\n]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^\n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "\n" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } } } [INFO] [stderr] | ^^ [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/kineticvm-75c47ee1789facb3/out/grammar.rs:86:824 [INFO] [stderr] | [INFO] [stderr] 86 | fn parse_white < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { ' ' | '\t' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[ \t]" ) , } } else { __state . mark_failure ( __pos , "[ \t]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } pub fn program < 'input > ( input : & 'input str ) -> ParseResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_program ( 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_program ( 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: usage of `contains_key` followed by `insert` on a `HashMap` [INFO] [stderr] --> src/asm/mod.rs:10:2 [INFO] [stderr] | [INFO] [stderr] 10 | if !register_map.contains_key(®ister) { [INFO] [stderr] | _____^ [INFO] [stderr] 11 | | let new_register = match register { [INFO] [stderr] 12 | | RegisterR::System(u) => u, [INFO] [stderr] 13 | | _ => Register(registers.next().unwrap()) [INFO] [stderr] 14 | | }; [INFO] [stderr] 15 | | register_map.insert(register, new_register); [INFO] [stderr] 16 | | } [INFO] [stderr] | |_____^ help: consider using: `register_map.entry(register)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::map_entry)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#map_entry [INFO] [stderr] [INFO] [stderr] warning: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices. [INFO] [stderr] --> src/asm/mod.rs:19:37 [INFO] [stderr] | [INFO] [stderr] 19 | fn make_register_map<'a> (objects : &Vec>, registers: &mut RangeFrom) -> HashMap, Register> { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ help: change this to: `&[ObjectR<'a>]` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::ptr_arg)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg [INFO] [stderr] [INFO] [stderr] warning: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices. [INFO] [stderr] --> src/asm/mod.rs:31:32 [INFO] [stderr] | [INFO] [stderr] 31 | fn make_label_map<'a>(objects: &Vec>) -> HashMap, i16> { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ help: change this to: `&[ObjectR<'a>]` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/asm/mod.rs:44:3 [INFO] [stderr] | [INFO] [stderr] 44 | if let &RegisterR::Immed(i) = val { [INFO] [stderr] | _________^ [INFO] [stderr] 45 | | registers[reg as usize] = i; [INFO] [stderr] 46 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::match_ref_pats)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_ref_pats [INFO] [stderr] help: instead of prefixing all patterns with `&`, you can dereference the expression [INFO] [stderr] | [INFO] [stderr] 44 | if let RegisterR::Immed(i) = *val { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ ^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/asm/mod.rs:47:3 [INFO] [stderr] | [INFO] [stderr] 47 | if let &RegisterR::Label(ref i) = val { [INFO] [stderr] | _________^ [INFO] [stderr] 48 | | registers[reg as usize] = labels[i]; [INFO] [stderr] 49 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_ref_pats [INFO] [stderr] help: instead of prefixing all patterns with `&`, you can dereference the expression [INFO] [stderr] | [INFO] [stderr] 47 | if let RegisterR::Label(ref i) = *val { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ [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] --> src/main.rs:75:1 [INFO] [stderr] | [INFO] [stderr] 75 | / unsafe fn transmute_slice<'a, U, T>(slice: &'a [T]) -> &'a [U] { [INFO] [stderr] 76 | | slice::from_raw_parts( [INFO] [stderr] 77 | | slice.as_ptr() as *const U, [INFO] [stderr] 78 | | (slice.len() * size_of::()) / size_of::() [INFO] [stderr] 79 | | ) [INFO] [stderr] 80 | | } [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] error: handle written amount returned or use `Write::write_all` instead [INFO] [stderr] --> src/main.rs:98:4 [INFO] [stderr] | [INFO] [stderr] 98 | stdout().write(&object).unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[deny(clippy::unused_io_amount)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount [INFO] [stderr] [INFO] [stderr] error: aborting due to previous error [INFO] [stderr] [INFO] [stderr] error: Could not compile `kineticvm`. [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stderr] warning: casting u8 to i16 may become silently lossy if types change [INFO] [stderr] --> src/vm/vmstate.rs:38:23 [INFO] [stderr] | [INFO] [stderr] 38 | return Value::Int(result as i16); [INFO] [stderr] | ^^^^^^^^^^^^^ help: try: `i16::from(result)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::cast_lossless)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/vm/mod.rs:16:25 [INFO] [stderr] | [INFO] [stderr] 16 | let registers = &words[1..(1+reg_count)]; [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: use: `1..=reg_count` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::range_plus_one)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:15:6 [INFO] [stderr] | [INFO] [stderr] 15 | ; if self . expected . len ( ) == 0 { try ! ( write ! ( fmt , "EOF" ) ) ; } [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: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:62:892 [INFO] [stderr] | [INFO] [stderr] 62 | fn parse_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_first_object ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , fo ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_object ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , o ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { if let Some(f) = fo { let mut v = vec![f]; v.extend_from_slice(&o); v } else { o } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } [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/kineticvm-75c47ee1789facb3/out/grammar.rs:62:1197 [INFO] [stderr] | [INFO] [stderr] 62 | fn parse_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_first_object ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , fo ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_object ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , o ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { if let Some(f) = fo { let mut v = vec![f]; v.extend_from_slice(&o); v } else { o } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } [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] 62 | fn parse_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_first_object ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , fo ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( () ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_object ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , o ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { if let Some(f) = fo { let mut v = vec![f]; v.extend_from_slice(&o); v } else { o } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:62:1240 [INFO] [stderr] | [INFO] [stderr] 62 | fn parse_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = match parse_first_object ( __input , __state , __pos ) { Matched ( newpos , value ) => { Matched ( newpos , Some ( value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match seq_res { Matched ( __pos , fo ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_object ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , o ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { if let Some(f) = fo { let mut v = vec![f]; v.extend_from_slice(&o); v } else { o } } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } [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: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:70:330 [INFO] [stderr] | [INFO] [stderr] 70 | fn parse_move_lines < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_move_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , l ) => { Matched ( __pos , { l } ) } Failed => Failed , } } } [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/kineticvm-75c47ee1789facb3/out/grammar.rs:70:635 [INFO] [stderr] | [INFO] [stderr] 70 | fn parse_move_lines < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_move_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , l ) => { Matched ( __pos , { l } ) } Failed => Failed , } } } [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] 70 | fn parse_move_lines < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( () ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_move_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , l ) => { Matched ( __pos , { l } ) } Failed => Failed , } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:70:678 [INFO] [stderr] | [INFO] [stderr] 70 | fn parse_move_lines < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __pos = if repeat_value . len ( ) > 0 { let sep_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_end_of_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_move_line ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } ; match seq_res { Matched ( __pos , l ) => { Matched ( __pos , { l } ) } Failed => Failed , } } } [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/kineticvm-75c47ee1789facb3/out/grammar.rs:74:946 [INFO] [stderr] | [INFO] [stderr] 74 | fn parse_source_reg < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < RegisterR<'input> > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = { let str_start = __pos ; match { let seq_res = match slice_eq ( __input , __state , __pos , "-" ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match seq_res { Matched ( __pos , _ ) => { { 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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , imm ) => { Matched ( __pos , { RegisterR::Immed(imm.parse::().unwrap()) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::User(Ident::from_str(u)) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "%" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_system_reg ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::System(u) } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::Label(Ident::from_str(u)) } ) } Failed => Failed , } } } Failed => Failed , } } } } } } } } } [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] 74 | fn parse_source_reg < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < RegisterR<'input> > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = { let str_start = __pos ; match { let seq_res = match slice_eq ( __input , __state , __pos , "-" ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match seq_res { Matched ( __pos , _ ) => { { 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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( () ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , imm ) => { Matched ( __pos , { RegisterR::Immed(imm.parse::().unwrap()) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::User(Ident::from_str(u)) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "%" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_system_reg ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::System(u) } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::Label(Ident::from_str(u)) } ) } Failed => Failed , } } } Failed => Failed , } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:74:989 [INFO] [stderr] | [INFO] [stderr] 74 | fn parse_source_reg < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < RegisterR<'input> > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = { let str_start = __pos ; match { let seq_res = match slice_eq ( __input , __state , __pos , "-" ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match seq_res { Matched ( __pos , _ ) => { { 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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , imm ) => { Matched ( __pos , { RegisterR::Immed(imm.parse::().unwrap()) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::User(Ident::from_str(u)) } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "%" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_system_reg ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::System(u) } ) } Failed => Failed , } } } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let str_start = __pos ; match parse_ident ( __input , __state , __pos ) { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , u ) => { Matched ( __pos , { RegisterR::Label(Ident::from_str(u)) } ) } Failed => Failed , } } } Failed => Failed , } } } } } } } } } [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 56 [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:78:2 [INFO] [stderr] | [INFO] [stderr] 78 | fn parse_system_reg < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Register > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "LHS" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::LHS } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "BIT_AND" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::BIT_AND } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "BIT_OR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::BIT_OR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "BIT_XOR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::BIT_XOR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "BIT_NOT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::BIT_NOT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "CODE_OBJECT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::CODE_OBJECT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "DIFF" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::DIFF } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "HALT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::HALT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MEM_OBJECT_SIZE" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MEM_OBJECT_SIZE } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MEM_OFFSET" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MEM_OFFSET } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MEM_PTR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MEM_PTR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "EQ" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::EQ } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MEM_VALUE" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MEM_VALUE } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "NOT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::NOT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "OUT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::OUT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "PC" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::PC } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "PRODUCT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::PRODUCT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "QUOTIENT" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::QUOTIENT } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "RHS" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::RHS } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SHIFT_AR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SHIFT_AR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SHIFT_LR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SHIFT_LR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SHIFT_L" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SHIFT_L } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SKIP_INSTR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SKIP_INSTR } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "SUM" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::SUM } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MAX" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MAX } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "MIN" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::MIN } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = { let seq_res = slice_eq ( __input , __state , __pos , "LINK" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::LINK } ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = slice_eq ( __input , __state , __pos , "IO_CHAR" ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { sys_registers::IO_CHAR } ) } Failed => Failed , } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } [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: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:80:739 [INFO] [stderr] | [INFO] [stderr] 80 | fn parse_ident < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < &'input str > { # ! [ allow ( non_snake_case , unused ) ] { 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 { 'a' ... 'z' | 'A' ... 'Z' | '_' | '-' | '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } } [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] 80 | fn parse_ident < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < &'input str > { # ! [ allow ( non_snake_case , unused ) ] { 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 { 'a' ... 'z' | 'A' ... 'Z' | '_' | '-' | '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( () ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:80:782 [INFO] [stderr] | [INFO] [stderr] 80 | fn parse_ident < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < &'input str > { # ! [ allow ( non_snake_case , unused ) ] { 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 { 'a' ... 'z' | 'A' ... 'Z' | '_' | '-' | '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z_-0-9]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } if repeat_value . len ( ) >= 1usize { Matched ( __repeat_pos , ( ) ) } else { Failed } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } } [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/kineticvm-75c47ee1789facb3/out/grammar.rs:82:318 [INFO] [stderr] | [INFO] [stderr] 82 | fn parse_optional_comment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_white ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' => __state . mark_failure ( __pos , "[^\n]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^\n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } } Failed => Failed , } } } } } [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] 82 | fn parse_optional_comment < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_white ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' => __state . mark_failure ( __pos , "[^\n]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^\n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } Failed => Failed , } } } Failed => Failed , } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/kineticvm-75c47ee1789facb3/out/grammar.rs:84:445 [INFO] [stderr] | [INFO] [stderr] 84 | fn parse_end_of_line < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "\n" ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' => __state . mark_failure ( __pos , "[^\n]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^\n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "\n" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } } } [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] 84 | fn parse_end_of_line < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "\n" ) } Failed => Failed , } } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let seq_res = parse_white ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = slice_eq ( __input , __state , __pos , ";" ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' => __state . mark_failure ( __pos , "[^\n]" ) , _ => Matched ( __next , ( ) ) , } } else { __state . mark_failure ( __pos , "[^\n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "\n" ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } } } [INFO] [stderr] | ^^ [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/kineticvm-75c47ee1789facb3/out/grammar.rs:86:824 [INFO] [stderr] | [INFO] [stderr] 86 | fn parse_white < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { ' ' | '\t' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[ \t]" ) , } } else { __state . mark_failure ( __pos , "[ \t]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } } pub fn program < 'input > ( input : & 'input str ) -> ParseResult < Vec> > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_program ( 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_program ( 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: usage of `contains_key` followed by `insert` on a `HashMap` [INFO] [stderr] --> src/asm/mod.rs:10:2 [INFO] [stderr] | [INFO] [stderr] 10 | if !register_map.contains_key(®ister) { [INFO] [stderr] | _____^ [INFO] [stderr] 11 | | let new_register = match register { [INFO] [stderr] 12 | | RegisterR::System(u) => u, [INFO] [stderr] 13 | | _ => Register(registers.next().unwrap()) [INFO] [stderr] 14 | | }; [INFO] [stderr] 15 | | register_map.insert(register, new_register); [INFO] [stderr] 16 | | } [INFO] [stderr] | |_____^ help: consider using: `register_map.entry(register)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::map_entry)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#map_entry [INFO] [stderr] [INFO] [stderr] warning: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices. [INFO] [stderr] --> src/asm/mod.rs:19:37 [INFO] [stderr] | [INFO] [stderr] 19 | fn make_register_map<'a> (objects : &Vec>, registers: &mut RangeFrom) -> HashMap, Register> { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ help: change this to: `&[ObjectR<'a>]` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::ptr_arg)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg [INFO] [stderr] [INFO] [stderr] warning: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices. [INFO] [stderr] --> src/asm/mod.rs:31:32 [INFO] [stderr] | [INFO] [stderr] 31 | fn make_label_map<'a>(objects: &Vec>) -> HashMap, i16> { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ help: change this to: `&[ObjectR<'a>]` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/asm/mod.rs:44:3 [INFO] [stderr] | [INFO] [stderr] 44 | if let &RegisterR::Immed(i) = val { [INFO] [stderr] | _________^ [INFO] [stderr] 45 | | registers[reg as usize] = i; [INFO] [stderr] 46 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::match_ref_pats)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_ref_pats [INFO] [stderr] help: instead of prefixing all patterns with `&`, you can dereference the expression [INFO] [stderr] | [INFO] [stderr] 44 | if let RegisterR::Immed(i) = *val { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ ^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/asm/mod.rs:47:3 [INFO] [stderr] | [INFO] [stderr] 47 | if let &RegisterR::Label(ref i) = val { [INFO] [stderr] | _________^ [INFO] [stderr] 48 | | registers[reg as usize] = labels[i]; [INFO] [stderr] 49 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_ref_pats [INFO] [stderr] help: instead of prefixing all patterns with `&`, you can dereference the expression [INFO] [stderr] | [INFO] [stderr] 47 | if let RegisterR::Label(ref i) = *val { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ [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] --> src/main.rs:75:1 [INFO] [stderr] | [INFO] [stderr] 75 | / unsafe fn transmute_slice<'a, U, T>(slice: &'a [T]) -> &'a [U] { [INFO] [stderr] 76 | | slice::from_raw_parts( [INFO] [stderr] 77 | | slice.as_ptr() as *const U, [INFO] [stderr] 78 | | (slice.len() * size_of::()) / size_of::() [INFO] [stderr] 79 | | ) [INFO] [stderr] 80 | | } [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] error: handle written amount returned or use `Write::write_all` instead [INFO] [stderr] --> src/main.rs:98:4 [INFO] [stderr] | [INFO] [stderr] 98 | stdout().write(&object).unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[deny(clippy::unused_io_amount)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount [INFO] [stderr] [INFO] [stderr] error: aborting due to previous error [INFO] [stderr] [INFO] [stderr] error: Could not compile `kineticvm`. [INFO] [stderr] [INFO] [stderr] To learn more, run the command again with --verbose. [INFO] running `"docker" "inspect" "33ef5d3e93acbd1221597dfa11b107427b494027c53f850cae91030a437dc9d0"` [INFO] running `"docker" "rm" "-f" "33ef5d3e93acbd1221597dfa11b107427b494027c53f850cae91030a437dc9d0"` [INFO] [stdout] 33ef5d3e93acbd1221597dfa11b107427b494027c53f850cae91030a437dc9d0