[INFO] updating cached repository exceptional-lang/exceptional [INFO] running `"git" "fetch" "--all"` [INFO] [stdout] Fetching origin [INFO] [stderr] From git://github.com/exceptional-lang/exceptional [INFO] [stderr] * branch HEAD -> FETCH_HEAD [INFO] running `"git" "clone" "work/cache/sources/gh/exceptional-lang/exceptional" "work/ex/clippy-test-run/sources/stable/gh/exceptional-lang/exceptional"` [INFO] [stderr] Cloning into 'work/ex/clippy-test-run/sources/stable/gh/exceptional-lang/exceptional'... [INFO] [stderr] done. [INFO] running `"git" "clone" "work/cache/sources/gh/exceptional-lang/exceptional" "work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/gh/exceptional-lang/exceptional"` [INFO] [stderr] Cloning into 'work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/gh/exceptional-lang/exceptional'... [INFO] [stderr] done. [INFO] running `"git" "rev-parse" "HEAD"` [INFO] [stdout] 02b6645854a847a55dd2332e4d5dd9c2ed31ce98 [INFO] sha for GitHub repo exceptional-lang/exceptional: 02b6645854a847a55dd2332e4d5dd9c2ed31ce98 [INFO] validating manifest of exceptional-lang/exceptional 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 exceptional-lang/exceptional 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 exceptional-lang/exceptional [INFO] finished frobbing exceptional-lang/exceptional [INFO] frobbed toml for exceptional-lang/exceptional written to work/ex/clippy-test-run/sources/stable/gh/exceptional-lang/exceptional/Cargo.toml [INFO] started frobbing exceptional-lang/exceptional [INFO] finished frobbing exceptional-lang/exceptional [INFO] frobbed toml for exceptional-lang/exceptional written to work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/gh/exceptional-lang/exceptional/Cargo.toml [INFO] crate exceptional-lang/exceptional 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 exceptional-lang/exceptional against stable for clippy-test-run [INFO] running `"docker" "create" "-v" "/mnt/big/crater/work/local/target-dirs/clippy-test-run/worker-1/stable:/opt/crater/target:rw,Z" "-v" "/mnt/big/crater/work/ex/clippy-test-run/sources/stable/gh/exceptional-lang/exceptional:/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] 3ecec242d5e6e99cd36ec479059705083c81e5d24cac7eb1e350ea4ebc4392c7 [INFO] running `"docker" "start" "-a" "3ecec242d5e6e99cd36ec479059705083c81e5d24cac7eb1e350ea4ebc4392c7"` [INFO] [stderr] Compiling peg v0.4.0 [INFO] [stderr] Checking fern v0.4.0 [INFO] [stderr] Checking num-bigint v0.1.39 [INFO] [stderr] Checking thread_local v0.3.3 [INFO] [stderr] Checking regex v0.2.2 [INFO] [stderr] Checking num-rational v0.1.38 [INFO] [stderr] Compiling exceptional v0.1.0 (/opt/crater/workdir) [INFO] [stderr] Checking num v0.1.39 [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/binding_map.rs:20:13 [INFO] [stderr] | [INFO] [stderr] 20 | parent: parent, [INFO] [stderr] | ^^^^^^^^^^^^^^ help: replace it with: `parent` [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/closure.rs:15:13 [INFO] [stderr] | [INFO] [stderr] 15 | instructions: instructions, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `instructions` [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/exception_handler.rs:22:13 [INFO] [stderr] | [INFO] [stderr] 22 | pattern: pattern, [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: replace it with: `pattern` [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/exception_handler.rs:23:13 [INFO] [stderr] | [INFO] [stderr] 23 | closure: closure, [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: replace it with: `closure` [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.rs:28:13 [INFO] [stderr] | [INFO] [stderr] 28 | bindings: bindings, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: replace it with: `bindings` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/binding_map.rs:20:13 [INFO] [stderr] | [INFO] [stderr] 20 | parent: parent, [INFO] [stderr] | ^^^^^^^^^^^^^^ help: replace it with: `parent` [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/closure.rs:15:13 [INFO] [stderr] | [INFO] [stderr] 15 | instructions: instructions, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `instructions` [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/exception_handler.rs:22:13 [INFO] [stderr] | [INFO] [stderr] 22 | pattern: pattern, [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: replace it with: `pattern` [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/exception_handler.rs:23:13 [INFO] [stderr] | [INFO] [stderr] 23 | closure: closure, [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: replace it with: `closure` [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.rs:28:13 [INFO] [stderr] | [INFO] [stderr] 28 | bindings: bindings, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: replace it with: `bindings` [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] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-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] = 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: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-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: unused import: `Shutdown` [INFO] [stderr] --> src/native.rs:14:16 [INFO] [stderr] | [INFO] [stderr] 14 | use std::net::{Shutdown, TcpListener, TcpStream}; [INFO] [stderr] | ^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(unused_imports)] on by default [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/native.rs:33:27 [INFO] [stderr] | [INFO] [stderr] 33 | Err(_) => return Err("can't read on this file descriptor".to_owned()), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `Err("can't read on this file descriptor".to_owned())` [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: `std::fs` [INFO] [stderr] --> src/vm.rs:9:5 [INFO] [stderr] | [INFO] [stderr] 9 | use std::fs; [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: unused import: `std::fs::File` [INFO] [stderr] --> src/vm.rs:10:5 [INFO] [stderr] | [INFO] [stderr] 10 | use std::fs::File; [INFO] [stderr] | ^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: unused import: `std::io::Write` [INFO] [stderr] --> src/vm.rs:11:5 [INFO] [stderr] | [INFO] [stderr] 11 | use std::io::Write; [INFO] [stderr] | ^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: returning the result of a let binding from a block. Consider returning the expression directly. [INFO] [stderr] --> src/vm.rs:57:9 [INFO] [stderr] | [INFO] [stderr] 57 | vm [INFO] [stderr] | ^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::let_and_return)] on by default [INFO] [stderr] note: this expression can be directly returned [INFO] [stderr] --> src/vm.rs:50:18 [INFO] [stderr] | [INFO] [stderr] 50 | let vm = Vm { [INFO] [stderr] | __________________^ [INFO] [stderr] 51 | | instructions: Rc::new(instructions), [INFO] [stderr] 52 | | pc: 0, [INFO] [stderr] 53 | | stack: Vec::new(), [INFO] [stderr] 54 | | frames: vec![frame], [INFO] [stderr] 55 | | file_descriptors: FileDescriptorMap::new(), [INFO] [stderr] 56 | | }; [INFO] [stderr] | |_________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return [INFO] [stderr] [INFO] [stderr] warning: returning the result of a let binding from a block. Consider returning the expression directly. [INFO] [stderr] --> src/vm.rs:70:9 [INFO] [stderr] | [INFO] [stderr] 70 | vm [INFO] [stderr] | ^^ [INFO] [stderr] | [INFO] [stderr] note: this expression can be directly returned [INFO] [stderr] --> src/vm.rs:63:18 [INFO] [stderr] | [INFO] [stderr] 63 | let vm = Vm { [INFO] [stderr] | __________________^ [INFO] [stderr] 64 | | instructions: Rc::new(vec![]), [INFO] [stderr] 65 | | pc: 0, [INFO] [stderr] 66 | | stack: Vec::new(), [INFO] [stderr] 67 | | frames: vec![frame], [INFO] [stderr] 68 | | file_descriptors: FileDescriptorMap::new(), [INFO] [stderr] 69 | | }; [INFO] [stderr] | |_________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-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] = 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: this looks like an `else if` but the `else` is missing [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-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: long literal lacking separators [INFO] [stderr] --> src/grammar.rs:12:56 [INFO] [stderr] | [INFO] [stderr] 12 | assert_eq!(parse_literal(&"11.1234"), l_number(111234, 10000)); [INFO] [stderr] | ^^^^^^ help: consider: `111_234` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unreadable_literal)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/native.rs:33:27 [INFO] [stderr] | [INFO] [stderr] 33 | Err(_) => return Err("can't read on this file descriptor".to_owned()), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `Err("can't read on this file descriptor".to_owned())` [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: `std::io::Write` [INFO] [stderr] --> src/vm.rs:11:5 [INFO] [stderr] | [INFO] [stderr] 11 | use std::io::Write; [INFO] [stderr] | ^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(unused_imports)] on by default [INFO] [stderr] [INFO] [stderr] warning: returning the result of a let binding from a block. Consider returning the expression directly. [INFO] [stderr] --> src/vm.rs:57:9 [INFO] [stderr] | [INFO] [stderr] 57 | vm [INFO] [stderr] | ^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::let_and_return)] on by default [INFO] [stderr] note: this expression can be directly returned [INFO] [stderr] --> src/vm.rs:50:18 [INFO] [stderr] | [INFO] [stderr] 50 | let vm = Vm { [INFO] [stderr] | __________________^ [INFO] [stderr] 51 | | instructions: Rc::new(instructions), [INFO] [stderr] 52 | | pc: 0, [INFO] [stderr] 53 | | stack: Vec::new(), [INFO] [stderr] 54 | | frames: vec![frame], [INFO] [stderr] 55 | | file_descriptors: FileDescriptorMap::new(), [INFO] [stderr] 56 | | }; [INFO] [stderr] | |_________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return [INFO] [stderr] [INFO] [stderr] warning: returning the result of a let binding from a block. Consider returning the expression directly. [INFO] [stderr] --> src/vm.rs:70:9 [INFO] [stderr] | [INFO] [stderr] 70 | vm [INFO] [stderr] | ^^ [INFO] [stderr] | [INFO] [stderr] note: this expression can be directly returned [INFO] [stderr] --> src/vm.rs:63:18 [INFO] [stderr] | [INFO] [stderr] 63 | let vm = Vm { [INFO] [stderr] | __________________^ [INFO] [stderr] 64 | | instructions: Rc::new(vec![]), [INFO] [stderr] 65 | | pc: 0, [INFO] [stderr] 66 | | stack: Vec::new(), [INFO] [stderr] 67 | | frames: vec![frame], [INFO] [stderr] 68 | | file_descriptors: FileDescriptorMap::new(), [INFO] [stderr] 69 | | }; [INFO] [stderr] | |_________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return [INFO] [stderr] [INFO] [stderr] warning: method is never used: `blank` [INFO] [stderr] --> src/closure.rs:20:5 [INFO] [stderr] | [INFO] [stderr] 20 | pub fn blank() -> Closure { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(dead_code)] on by default [INFO] [stderr] [INFO] [stderr] warning: variant is never constructed: `File` [INFO] [stderr] --> src/native.rs:23:5 [INFO] [stderr] | [INFO] [stderr] 23 | File(File), [INFO] [stderr] | ^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: method is never used: `empty` [INFO] [stderr] --> src/vm.rs:60:5 [INFO] [stderr] | [INFO] [stderr] 60 | pub fn empty() -> Vm { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: method is never used: `pop` [INFO] [stderr] --> src/vm.rs:251:5 [INFO] [stderr] | [INFO] [stderr] 251 | pub fn pop(&mut self) -> Option { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: method is never used: `local_assign` [INFO] [stderr] --> src/vm.rs:259:5 [INFO] [stderr] | [INFO] [stderr] 259 | pub fn local_assign(&mut self, name: &String, value: Value) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `Box>`. Consider using just `Vec` [INFO] [stderr] --> src/ast.rs:12:8 [INFO] [stderr] | [INFO] [stderr] 12 | Fn(Box>, Box>), [INFO] [stderr] | ^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::box_vec)] on by default [INFO] [stderr] = help: `Vec` is already on the heap, `Box>` makes an extra allocation. [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#box_vec [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `Box>`. Consider using just `Vec` [INFO] [stderr] --> src/ast.rs:12:26 [INFO] [stderr] | [INFO] [stderr] 12 | Fn(Box>, Box>), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: `Vec` is already on the heap, `Box>` makes an extra allocation. [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#box_vec [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `Box>`. Consider using just `Vec` [INFO] [stderr] --> src/ast.rs:22:21 [INFO] [stderr] | [INFO] [stderr] 22 | Rescue(Pattern, Box>), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: `Vec` is already on the heap, `Box>` makes an extra allocation. [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#box_vec [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/binding_map.rs:24:39 [INFO] [stderr] | [INFO] [stderr] 24 | pub fn fetch(&self, binding_name: &String) -> Option { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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 `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/binding_map.rs:34:50 [INFO] [stderr] | [INFO] [stderr] 34 | pub fn local_assign(&mut self, binding_name: &String, value: Value) { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/binding_map.rs:38:44 [INFO] [stderr] | [INFO] [stderr] 38 | pub fn assign(&mut self, binding_name: &String, value: Value) { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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 seem to be trying to match on a boolean expression [INFO] [stderr] --> src/binding_map.rs:39:9 [INFO] [stderr] | [INFO] [stderr] 39 | / match self.has_binding(binding_name) { [INFO] [stderr] 40 | | true => self.local_assign(binding_name, value), [INFO] [stderr] 41 | | false => match self.parent { [INFO] [stderr] 42 | | Some(ref mut parent) => parent.assign(binding_name, value), [INFO] [stderr] 43 | | None => panic!("no such binding"), [INFO] [stderr] 44 | | }, [INFO] [stderr] 45 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::match_bool)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [INFO] [stderr] help: consider using an if/else expression [INFO] [stderr] | [INFO] [stderr] 39 | if self.has_binding(binding_name) { self.local_assign(binding_name, value) } else { match self.parent { [INFO] [stderr] 40 | Some(ref mut parent) => parent.assign(binding_name, value), [INFO] [stderr] 41 | None => panic!("no such binding"), [INFO] [stderr] 42 | } } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/binding_map.rs:48:45 [INFO] [stderr] | [INFO] [stderr] 48 | pub fn has_binding(&self, binding_name: &String) -> bool { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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/compiler.rs:6:5 [INFO] [stderr] | [INFO] [stderr] 6 | / match statement { [INFO] [stderr] 7 | | &Statement::Assign(local, ref binding_name, ref expression) => { [INFO] [stderr] 8 | | let mut instructions = compile_expression(expression); [INFO] [stderr] 9 | | let instruction = match local { [INFO] [stderr] ... | [INFO] [stderr] 47 | | // s => panic!("not implemented: {:?}", s), [INFO] [stderr] 48 | | } [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] 6 | match *statement { [INFO] [stderr] 7 | Statement::Assign(local, ref binding_name, ref expression) => { [INFO] [stderr] 8 | let mut instructions = compile_expression(expression); [INFO] [stderr] 9 | let instruction = match local { [INFO] [stderr] 10 | true => Instruction::LocalAssign(binding_name.to_owned()), [INFO] [stderr] 11 | false => Instruction::Assign(binding_name.to_owned()), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to match on a boolean expression [INFO] [stderr] --> src/compiler.rs:9:31 [INFO] [stderr] | [INFO] [stderr] 9 | let instruction = match local { [INFO] [stderr] | _______________________________^ [INFO] [stderr] 10 | | true => Instruction::LocalAssign(binding_name.to_owned()), [INFO] [stderr] 11 | | false => Instruction::Assign(binding_name.to_owned()), [INFO] [stderr] 12 | | }; [INFO] [stderr] | |_____________^ help: consider using an if/else expression: `if local { Instruction::LocalAssign(binding_name.to_owned()) } else { Instruction::Assign(binding_name.to_owned()) }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/compiler.rs:52:5 [INFO] [stderr] | [INFO] [stderr] 52 | / match expression { [INFO] [stderr] 53 | | &Expression::Literal(ref literal) => match literal { [INFO] [stderr] 54 | | &Literal::Map(ref pairs) => { [INFO] [stderr] 55 | | let mut map_instructions = pairs [INFO] [stderr] ... | [INFO] [stderr] 88 | | } [INFO] [stderr] 89 | | } [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] 52 | match *expression { [INFO] [stderr] 53 | Expression::Literal(ref literal) => match literal { [INFO] [stderr] 54 | &Literal::Map(ref pairs) => { [INFO] [stderr] 55 | let mut map_instructions = pairs [INFO] [stderr] 56 | .iter() [INFO] [stderr] 57 | .flat_map(|&(ref key, ref value)| { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/compiler.rs:53:46 [INFO] [stderr] | [INFO] [stderr] 53 | &Expression::Literal(ref literal) => match literal { [INFO] [stderr] | ______________________________________________^ [INFO] [stderr] 54 | | &Literal::Map(ref pairs) => { [INFO] [stderr] 55 | | let mut map_instructions = pairs [INFO] [stderr] 56 | | .iter() [INFO] [stderr] ... | [INFO] [stderr] 67 | | _ => vec![Instruction::Push(literal.to_owned())], [INFO] [stderr] 68 | | }, [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] 53 | &Expression::Literal(ref literal) => match *literal { [INFO] [stderr] 54 | Literal::Map(ref pairs) => { [INFO] [stderr] | [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/compiler.rs:108:28 [INFO] [stderr] | [INFO] [stderr] 108 | pub fn compile(statements: &Vec) -> InstructionSequence { [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: change this to: `&[Statement]` [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/exception_handler.rs:31:9 [INFO] [stderr] | [INFO] [stderr] 31 | / match pattern { [INFO] [stderr] 32 | | &Pattern::Number(ref ratio) => ExceptionHandler::match_number(ratio, value), [INFO] [stderr] 33 | | &Pattern::CharString(ref string) => ExceptionHandler::match_string(string, value), [INFO] [stderr] 34 | | &Pattern::Boolean(bool) => ExceptionHandler::match_bool(bool, value), [INFO] [stderr] ... | [INFO] [stderr] 39 | | } [INFO] [stderr] 40 | | } [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] 31 | match *pattern { [INFO] [stderr] 32 | Pattern::Number(ref ratio) => ExceptionHandler::match_number(ratio, value), [INFO] [stderr] 33 | Pattern::CharString(ref string) => ExceptionHandler::match_string(string, value), [INFO] [stderr] 34 | Pattern::Boolean(bool) => ExceptionHandler::match_bool(bool, value), [INFO] [stderr] 35 | Pattern::Map(ref pairs) => ExceptionHandler::match_map(pairs, value), [INFO] [stderr] 36 | Pattern::Identifier(ref name) => ExceptionHandler::match_identifier(name, value), [INFO] [stderr] ... [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/exception_handler.rs:43:37 [INFO] [stderr] | [INFO] [stderr] 43 | fn match_string_match(bindings: &Vec, regex: &Regex, value: &Value) -> MatchedBindings { [INFO] [stderr] | ^^^^^^^^^^^^ help: change this to: `&[String]` [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/exception_handler.rs:44:9 [INFO] [stderr] | [INFO] [stderr] 44 | / if let &Value::CharString(ref char_str) = value { [INFO] [stderr] 45 | | if let Some(mat) = regex.captures(char_str) { [INFO] [stderr] 46 | | let results = bindings [INFO] [stderr] 47 | | .iter() [INFO] [stderr] ... | [INFO] [stderr] 62 | | None [INFO] [stderr] 63 | | } [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] 44 | if let Value::CharString(ref char_str) = *value { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/exception_handler.rs:67:9 [INFO] [stderr] | [INFO] [stderr] 67 | / match value { [INFO] [stderr] 68 | | &Value::Number(ref number) => match ratio.eq(number) { [INFO] [stderr] 69 | | true => Some(BTreeMap::new()), [INFO] [stderr] 70 | | _ => None, [INFO] [stderr] 71 | | }, [INFO] [stderr] 72 | | _ => None, [INFO] [stderr] 73 | | } [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] 67 | match *value { [INFO] [stderr] 68 | Value::Number(ref number) => match ratio.eq(number) { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to match on a boolean expression [INFO] [stderr] --> src/exception_handler.rs:68:43 [INFO] [stderr] | [INFO] [stderr] 68 | &Value::Number(ref number) => match ratio.eq(number) { [INFO] [stderr] | ___________________________________________^ [INFO] [stderr] 69 | | true => Some(BTreeMap::new()), [INFO] [stderr] 70 | | _ => None, [INFO] [stderr] 71 | | }, [INFO] [stderr] | |_____________^ help: consider using an if/else expression: `if ratio.eq(number) { Some(BTreeMap::new()) } else { None }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/exception_handler.rs:76:29 [INFO] [stderr] | [INFO] [stderr] 76 | fn match_string(string: &String, value: &Value) -> MatchedBindings { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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/exception_handler.rs:77:9 [INFO] [stderr] | [INFO] [stderr] 77 | / match value { [INFO] [stderr] 78 | | &Value::CharString(ref str) => match str.eq(string) { [INFO] [stderr] 79 | | true => Some(BTreeMap::new()), [INFO] [stderr] 80 | | _ => None, [INFO] [stderr] 81 | | }, [INFO] [stderr] 82 | | _ => None, [INFO] [stderr] 83 | | } [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] 77 | match *value { [INFO] [stderr] 78 | Value::CharString(ref str) => match str.eq(string) { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to match on a boolean expression [INFO] [stderr] --> src/exception_handler.rs:78:44 [INFO] [stderr] | [INFO] [stderr] 78 | &Value::CharString(ref str) => match str.eq(string) { [INFO] [stderr] | ____________________________________________^ [INFO] [stderr] 79 | | true => Some(BTreeMap::new()), [INFO] [stderr] 80 | | _ => None, [INFO] [stderr] 81 | | }, [INFO] [stderr] | |_____________^ help: consider using an if/else expression: `if str.eq(string) { Some(BTreeMap::new()) } else { None }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/exception_handler.rs:87:9 [INFO] [stderr] | [INFO] [stderr] 87 | / match value { [INFO] [stderr] 88 | | &Value::Boolean(other_bool) => match b == other_bool { [INFO] [stderr] 89 | | true => Some(BTreeMap::new()), [INFO] [stderr] 90 | | _ => None, [INFO] [stderr] 91 | | }, [INFO] [stderr] 92 | | _ => None, [INFO] [stderr] 93 | | } [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] 87 | match *value { [INFO] [stderr] 88 | Value::Boolean(other_bool) => match b == other_bool { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to match on a boolean expression [INFO] [stderr] --> src/exception_handler.rs:88:44 [INFO] [stderr] | [INFO] [stderr] 88 | &Value::Boolean(other_bool) => match b == other_bool { [INFO] [stderr] | ____________________________________________^ [INFO] [stderr] 89 | | true => Some(BTreeMap::new()), [INFO] [stderr] 90 | | _ => None, [INFO] [stderr] 91 | | }, [INFO] [stderr] | |_____________^ help: consider using an if/else expression: `if b == other_bool { Some(BTreeMap::new()) } else { None }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [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/exception_handler.rs:96:25 [INFO] [stderr] | [INFO] [stderr] 96 | fn match_map(pairs: &Vec<(Pattern, Pattern)>, value: &Value) -> MatchedBindings { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `&[(Pattern, Pattern)]` [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/exception_handler.rs:97:9 [INFO] [stderr] | [INFO] [stderr] 97 | / match value { [INFO] [stderr] 98 | | &Value::Map(ref btreemap) => { [INFO] [stderr] 99 | | let mut bindings: BTreeMap = BTreeMap::new(); [INFO] [stderr] 100 | | for &(ref key, ref pattern_value) in pairs.iter() { [INFO] [stderr] ... | [INFO] [stderr] 127 | | _ => None, [INFO] [stderr] 128 | | } [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] 97 | match *value { [INFO] [stderr] 98 | Value::Map(ref btreemap) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: redundant pattern matching, consider using `is_none()` [INFO] [stderr] --> src/exception_handler.rs:108:28 [INFO] [stderr] | [INFO] [stderr] 108 | if let None = maybe_nested_bindings { [INFO] [stderr] | _____________________- ^^^^ [INFO] [stderr] 109 | | return None; [INFO] [stderr] 110 | | } [INFO] [stderr] | |_____________________- help: try this: `if maybe_nested_bindings.is_none()` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::redundant_pattern_matching)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/exception_handler.rs:131:31 [INFO] [stderr] | [INFO] [stderr] 131 | fn match_identifier(name: &String, value: &Value) -> MatchedBindings { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-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/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:62:310 [INFO] [stderr] | [INFO] [stderr] 62 | fn parse_statements < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] { 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 = parse___ ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_statement ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } } [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/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:90:330 [INFO] [stderr] | [INFO] [stderr] 90 | fn parse_callArguments < '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 = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_expression ( __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 , args ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:116:648 [INFO] [stderr] | [INFO] [stderr] 116 | fn parse_accessExpression < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , target ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_propertyAccess ( __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 , repeat_value ) } else { Failed } } ; match seq_res { Matched ( __pos , properties ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:143:695 [INFO] [stderr] | [INFO] [stderr] 143 | fn parse_digits < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => 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 } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unit_arg)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 143 | fn parse_digits < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => 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 } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:143:738 [INFO] [stderr] | [INFO] [stderr] 143 | fn parse_digits < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => 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 } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:165:317 [INFO] [stderr] | [INFO] [stderr] 165 | fn parse_functionArgumentList < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] { 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 = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_identifier ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } } [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/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:175:342 [INFO] [stderr] | [INFO] [stderr] 175 | fn parse_keyPairList < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<(Expression, Expression)> > { # ! [ 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 = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = { let seq_res = parse_expression ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , key ) => { { let seq_res = parse_fatArrow ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_expression ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , value ) => { Matched ( __pos , { (key, value) } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; 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 , pairs ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:187:340 [INFO] [stderr] | [INFO] [stderr] 187 | fn parse_patternPairList < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<(Pattern, Pattern)> > { # ! [ 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 = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = { let seq_res = parse_patternKey ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , key ) => { { let seq_res = parse_fatArrow ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_pattern ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , value ) => { Matched ( __pos , { (key, value) } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; 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 , pairs ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:243:733 [INFO] [stderr] | [INFO] [stderr] 243 | fn parse___ < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[ \n]" ) , } } else { __state . mark_failure ( __pos , "[ \n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_comment ( __input , __state , __pos ) } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 243 | fn parse___ < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[ \n]" ) , } } else { __state . mark_failure ( __pos , "[ \n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => parse_comment ( __input , __state , __pos ) } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:308 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:465 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:622 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:773 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:926 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [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] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:492 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( input , & mut state , 0 ) { Matched ( pos , value ) => { if pos == input . len ( ) { return Ok ( value ) } } _ => { } } let ( line , col ) = pos_to_line ( input , state . max_err_pos ) ; Err ( ParseError { line : line , column : col , offset : state . max_err_pos , expected : state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_lifetimes)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:664 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( 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_statements ( 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: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:991 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( input , & mut state , 0 ) { Matched ( pos , value ) => { if pos == input . len ( ) { return Ok ( value ) } } _ => { } } let ( line , col ) = pos_to_line ( input , state . max_err_pos ) ; Err ( ParseError { line : line , column : col , offset : state . max_err_pos , expected : state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:1159 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( 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_expression ( input , & mut state , 0 ) { if pos == input . len ( ) { return Ok ( value ) } }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] [INFO] [stderr] warning: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:1486 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( input , & mut state , 0 ) { Matched ( pos , value ) => { if pos == input . len ( ) { return Ok ( value ) } } _ => { } } let ( line , col ) = pos_to_line ( input , state . max_err_pos ) ; Err ( ParseError { line : line , column : col , offset : state . max_err_pos , expected : state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:1648 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( 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_literal ( input , & mut state , 0 ) { if pos == input . len ( ) { return Ok ( value ) } }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] [INFO] [stderr] warning: transmute from a type (`*const for<'r> fn(&'r mut vm::Vm) -> std::vec::Vec`) to the type that it points to (`for<'r> fn(&'r mut vm::Vm) -> std::vec::Vec`) [INFO] [stderr] --> src/instructions.rs:35:24 [INFO] [stderr] | [INFO] [stderr] 35 | let func = transmute:: InstructionSequence>(self.function); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::crosspointer_transmute)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#crosspointer_transmute [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/native.rs:31:9 [INFO] [stderr] | [INFO] [stderr] 31 | / match self { [INFO] [stderr] 32 | | &mut FileDescriptor::TcpStream(ref mut s) => match s.read_to_string(&mut buffer) { [INFO] [stderr] 33 | | Err(_) => return Err("can't read on this file descriptor".to_owned()), [INFO] [stderr] 34 | | Ok(_) => Ok(buffer), [INFO] [stderr] 35 | | }, [INFO] [stderr] 36 | | _ => Err("can't read on this file descriptor".to_owned()), [INFO] [stderr] 37 | | } [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] 31 | match *self { [INFO] [stderr] 32 | FileDescriptor::TcpStream(ref mut s) => match s.read_to_string(&mut buffer) { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/native.rs:41:9 [INFO] [stderr] | [INFO] [stderr] 41 | / match self { [INFO] [stderr] 42 | | &mut FileDescriptor::TcpStream(ref mut s) => s [INFO] [stderr] 43 | | .write(string.as_bytes()) [INFO] [stderr] 44 | | .or_else(|e| Err(format!("couldn't write to file descriptor: {:?}", e))), [INFO] [stderr] 45 | | _ => Err("can't write to this file descriptor".to_owned()), [INFO] [stderr] 46 | | } [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] 41 | match *self { [INFO] [stderr] 42 | FileDescriptor::TcpStream(ref mut s) => s [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/native.rs:72:9 [INFO] [stderr] | [INFO] [stderr] 72 | / match self { [INFO] [stderr] 73 | | &FileDescriptor::File(ref f) => unsafe { [INFO] [stderr] 74 | | FileDescriptor::File(File::from_raw_fd(f.as_raw_fd())) [INFO] [stderr] 75 | | }, [INFO] [stderr] ... | [INFO] [stderr] 81 | | }, [INFO] [stderr] 82 | | } [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] 72 | match *self { [INFO] [stderr] 73 | FileDescriptor::File(ref f) => unsafe { [INFO] [stderr] 74 | FileDescriptor::File(File::from_raw_fd(f.as_raw_fd())) [INFO] [stderr] 75 | }, [INFO] [stderr] 76 | FileDescriptor::TcpStream(ref t) => unsafe { [INFO] [stderr] 77 | FileDescriptor::TcpStream(TcpStream::from_raw_fd(t.as_raw_fd())) [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: redundant pattern matching, consider using `is_ok()` [INFO] [stderr] --> src/native.rs:106:12 [INFO] [stderr] | [INFO] [stderr] 106 | if let Ok(_) = file.read_to_string(&mut contents) { [INFO] [stderr] | _____- ^^^^^ [INFO] [stderr] 107 | | return Ok(contents); [INFO] [stderr] 108 | | } else { [INFO] [stderr] 109 | | Err("Can't read file".to_owned()) [INFO] [stderr] 110 | | } [INFO] [stderr] | |_____- help: try this: `if file.read_to_string(&mut contents).is_ok()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/native.rs:129:30 [INFO] [stderr] | [INFO] [stderr] 129 | fn write_file_contents(path: &String, content: &String) -> Result<(), String> { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/native.rs:129:48 [INFO] [stderr] | [INFO] [stderr] 129 | fn write_file_contents(path: &String, content: &String) -> Result<(), String> { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: redundant pattern matching, consider using `is_ok()` [INFO] [stderr] --> src/native.rs:135:12 [INFO] [stderr] | [INFO] [stderr] 135 | if let Ok(_) = file.write_all(content.as_bytes()) { [INFO] [stderr] | _____- ^^^^^ [INFO] [stderr] 136 | | Ok(()) [INFO] [stderr] 137 | | } else { [INFO] [stderr] 138 | | Err("Can't write file".to_owned()) [INFO] [stderr] 139 | | } [INFO] [stderr] | |_____- help: try this: `if file.write_all(content.as_bytes()).is_ok()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching [INFO] [stderr] [INFO] [stderr] warning: use of `ok_or` followed by a function call [INFO] [stderr] --> src/native.rs:248:18 [INFO] [stderr] | [INFO] [stderr] 248 | .ok_or("socket not found".to_owned()) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `ok_or_else(|| "socket not found".to_owned())` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::or_fun_call)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/native.rs:250:21 [INFO] [stderr] | [INFO] [stderr] 250 | / if let &FileDescriptor::TcpListener(ref l) = descriptor { [INFO] [stderr] 251 | | Ok(l) [INFO] [stderr] 252 | | } else { [INFO] [stderr] 253 | | Err("socket is not a socket".to_owned()) [INFO] [stderr] 254 | | } [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] 250 | if let FileDescriptor::TcpListener(ref l) = *descriptor { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: use of `ok_or` followed by a function call [INFO] [stderr] --> src/native.rs:289:18 [INFO] [stderr] | [INFO] [stderr] 289 | .ok_or("file descriptor not found".to_owned()) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `ok_or_else(|| "file descriptor not found".to_owned())` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call [INFO] [stderr] [INFO] [stderr] warning: use of `ok_or` followed by a function call [INFO] [stderr] --> src/native.rs:317:18 [INFO] [stderr] | [INFO] [stderr] 317 | .ok_or("file descriptor not found".to_owned()) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `ok_or_else(|| "file descriptor not found".to_owned())` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `Box>`. Consider using just `Vec` [INFO] [stderr] --> src/value.rs:16:16 [INFO] [stderr] | [INFO] [stderr] 16 | Closure(Rc>>, Rc), [INFO] [stderr] | ^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: `Vec` is already on the heap, `Box>` makes an extra allocation. [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#box_vec [INFO] [stderr] [INFO] [stderr] warning: useless use of `format!` [INFO] [stderr] --> src/value.rs:37:21 [INFO] [stderr] | [INFO] [stderr] 37 | Err(format!("Subtraction of closures is not supported")) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using .to_string(): `"Subtraction of closures is not supported".to_string()` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::useless_format)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_format [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/value.rs:100:75 [INFO] [stderr] | [INFO] [stderr] 100 | | (&Value::Number(ref ratio), Value::Boolean(ref boolean)) => match boolean { [INFO] [stderr] | ___________________________________________________________________________^ [INFO] [stderr] 101 | | &true => Ok(Value::Number(ratio.clone())), [INFO] [stderr] 102 | | &false => Ok(Value::Number(Ratio::new(BigInt::zero(), BigInt::one()))), [INFO] [stderr] 103 | | }, [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] 100 | | (&Value::Number(ref ratio), Value::Boolean(ref boolean)) => match *boolean { [INFO] [stderr] 101 | true => Ok(Value::Number(ratio.clone())), [INFO] [stderr] 102 | false => Ok(Value::Number(Ratio::new(BigInt::zero(), BigInt::one()))), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/value.rs:105:77 [INFO] [stderr] | [INFO] [stderr] 105 | | (&Value::Boolean(ref boolean), Value::CharString(ref str)) => match boolean { [INFO] [stderr] | _____________________________________________________________________________^ [INFO] [stderr] 106 | | &true => Ok(Value::CharString(str.clone())), [INFO] [stderr] 107 | | &false => Ok(Value::CharString("".to_owned())), [INFO] [stderr] 108 | | }, [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] 105 | | (&Value::Boolean(ref boolean), Value::CharString(ref str)) => match *boolean { [INFO] [stderr] 106 | true => Ok(Value::CharString(str.clone())), [INFO] [stderr] 107 | false => Ok(Value::CharString("".to_owned())), [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/vm.rs:73:5 [INFO] [stderr] | [INFO] [stderr] 73 | / pub fn run<'b>(&'b mut self) { [INFO] [stderr] 74 | | loop { [INFO] [stderr] 75 | | let insn_result = Vm::next_instruction(self); [INFO] [stderr] 76 | | let instruction; [INFO] [stderr] ... | [INFO] [stderr] 244 | | } [INFO] [stderr] 245 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: useless use of `format!` [INFO] [stderr] --> src/vm.rs:112:37 [INFO] [stderr] | [INFO] [stderr] 112 | None => Err(format!("expected a closure, got None")), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using .to_string(): `"expected a closure, got None".to_string()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_format [INFO] [stderr] [INFO] [stderr] warning: identical conversion [INFO] [stderr] --> src/vm.rs:145:31 [INFO] [stderr] | [INFO] [stderr] 145 | let map = (0..size) [INFO] [stderr] | _______________________________^ [INFO] [stderr] 146 | | .into_iter() [INFO] [stderr] | |____________________________________^ help: consider removing `.into_iter()`: `(0..size)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::identity_conversion)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#identity_conversion [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/vm.rs:255:35 [INFO] [stderr] | [INFO] [stderr] 255 | pub fn fetch(&mut self, name: &String) -> Option { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/vm.rs:259:42 [INFO] [stderr] | [INFO] [stderr] 259 | pub fn local_assign(&mut self, name: &String, value: Value) { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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/vm.rs:334:9 [INFO] [stderr] | [INFO] [stderr] 334 | / match literal { [INFO] [stderr] 335 | | &Literal::Number(ref num) => Value::Number(num.to_owned()), [INFO] [stderr] 336 | | &Literal::CharString(ref str) => Value::CharString(str.to_string()), [INFO] [stderr] 337 | | &Literal::Fn(ref args, ref statements) => { [INFO] [stderr] ... | [INFO] [stderr] 343 | | _ => panic!("not implemented literal_to_value for {:?}", literal), [INFO] [stderr] 344 | | } [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] 334 | match *literal { [INFO] [stderr] 335 | Literal::Number(ref num) => Value::Number(num.to_owned()), [INFO] [stderr] 336 | Literal::CharString(ref str) => Value::CharString(str.to_string()), [INFO] [stderr] 337 | Literal::Fn(ref args, ref statements) => { [INFO] [stderr] 338 | // Statements should be compiled ahead of time [INFO] [stderr] 339 | let closure = Closure::new(Rc::new(compile(&statements)), top_bindings); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/main.rs:26:17 [INFO] [stderr] | [INFO] [stderr] 26 | fn exec(source: &String) { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: use of `ok_or` followed by a function call [INFO] [stderr] --> src/main.rs:41:10 [INFO] [stderr] | [INFO] [stderr] 41 | .ok_or("No path given, stopping".to_string()) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `ok_or_else(|| "No path given, stopping".to_string())` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call [INFO] [stderr] [INFO] [stderr] warning: variant is never constructed: `File` [INFO] [stderr] --> src/native.rs:23:5 [INFO] [stderr] | [INFO] [stderr] 23 | File(File), [INFO] [stderr] | ^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(dead_code)] on by default [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to match on a boolean expression [INFO] [stderr] --> src/test_helpers.rs:24:5 [INFO] [stderr] | [INFO] [stderr] 24 | / match b { [INFO] [stderr] 25 | | true => Literal::Boolean(true), [INFO] [stderr] 26 | | false => Literal::Boolean(false), [INFO] [stderr] 27 | | } [INFO] [stderr] | |_____^ help: consider using an if/else expression: `if b { Literal::Boolean(true) } else { Literal::Boolean(false) }` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::match_bool)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `Box>`. Consider using just `Vec` [INFO] [stderr] --> src/ast.rs:12:8 [INFO] [stderr] | [INFO] [stderr] 12 | Fn(Box>, Box>), [INFO] [stderr] | ^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::box_vec)] on by default [INFO] [stderr] = help: `Vec` is already on the heap, `Box>` makes an extra allocation. [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#box_vec [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `Box>`. Consider using just `Vec` [INFO] [stderr] --> src/ast.rs:12:26 [INFO] [stderr] | [INFO] [stderr] 12 | Fn(Box>, Box>), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: `Vec` is already on the heap, `Box>` makes an extra allocation. [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#box_vec [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `Box>`. Consider using just `Vec` [INFO] [stderr] --> src/ast.rs:22:21 [INFO] [stderr] | [INFO] [stderr] 22 | Rescue(Pattern, Box>), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: `Vec` is already on the heap, `Box>` makes an extra allocation. [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#box_vec [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/binding_map.rs:24:39 [INFO] [stderr] | [INFO] [stderr] 24 | pub fn fetch(&self, binding_name: &String) -> Option { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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 `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/binding_map.rs:34:50 [INFO] [stderr] | [INFO] [stderr] 34 | pub fn local_assign(&mut self, binding_name: &String, value: Value) { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/binding_map.rs:38:44 [INFO] [stderr] | [INFO] [stderr] 38 | pub fn assign(&mut self, binding_name: &String, value: Value) { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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 seem to be trying to match on a boolean expression [INFO] [stderr] --> src/binding_map.rs:39:9 [INFO] [stderr] | [INFO] [stderr] 39 | / match self.has_binding(binding_name) { [INFO] [stderr] 40 | | true => self.local_assign(binding_name, value), [INFO] [stderr] 41 | | false => match self.parent { [INFO] [stderr] 42 | | Some(ref mut parent) => parent.assign(binding_name, value), [INFO] [stderr] 43 | | None => panic!("no such binding"), [INFO] [stderr] 44 | | }, [INFO] [stderr] 45 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [INFO] [stderr] help: consider using an if/else expression [INFO] [stderr] | [INFO] [stderr] 39 | if self.has_binding(binding_name) { self.local_assign(binding_name, value) } else { match self.parent { [INFO] [stderr] 40 | Some(ref mut parent) => parent.assign(binding_name, value), [INFO] [stderr] 41 | None => panic!("no such binding"), [INFO] [stderr] 42 | } } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/binding_map.rs:48:45 [INFO] [stderr] | [INFO] [stderr] 48 | pub fn has_binding(&self, binding_name: &String) -> bool { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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/compiler.rs:6:5 [INFO] [stderr] | [INFO] [stderr] 6 | / match statement { [INFO] [stderr] 7 | | &Statement::Assign(local, ref binding_name, ref expression) => { [INFO] [stderr] 8 | | let mut instructions = compile_expression(expression); [INFO] [stderr] 9 | | let instruction = match local { [INFO] [stderr] ... | [INFO] [stderr] 47 | | // s => panic!("not implemented: {:?}", s), [INFO] [stderr] 48 | | } [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] 6 | match *statement { [INFO] [stderr] 7 | Statement::Assign(local, ref binding_name, ref expression) => { [INFO] [stderr] 8 | let mut instructions = compile_expression(expression); [INFO] [stderr] 9 | let instruction = match local { [INFO] [stderr] 10 | true => Instruction::LocalAssign(binding_name.to_owned()), [INFO] [stderr] 11 | false => Instruction::Assign(binding_name.to_owned()), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to match on a boolean expression [INFO] [stderr] --> src/compiler.rs:9:31 [INFO] [stderr] | [INFO] [stderr] 9 | let instruction = match local { [INFO] [stderr] | _______________________________^ [INFO] [stderr] 10 | | true => Instruction::LocalAssign(binding_name.to_owned()), [INFO] [stderr] 11 | | false => Instruction::Assign(binding_name.to_owned()), [INFO] [stderr] 12 | | }; [INFO] [stderr] | |_____________^ help: consider using an if/else expression: `if local { Instruction::LocalAssign(binding_name.to_owned()) } else { Instruction::Assign(binding_name.to_owned()) }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/compiler.rs:52:5 [INFO] [stderr] | [INFO] [stderr] 52 | / match expression { [INFO] [stderr] 53 | | &Expression::Literal(ref literal) => match literal { [INFO] [stderr] 54 | | &Literal::Map(ref pairs) => { [INFO] [stderr] 55 | | let mut map_instructions = pairs [INFO] [stderr] ... | [INFO] [stderr] 88 | | } [INFO] [stderr] 89 | | } [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] 52 | match *expression { [INFO] [stderr] 53 | Expression::Literal(ref literal) => match literal { [INFO] [stderr] 54 | &Literal::Map(ref pairs) => { [INFO] [stderr] 55 | let mut map_instructions = pairs [INFO] [stderr] 56 | .iter() [INFO] [stderr] 57 | .flat_map(|&(ref key, ref value)| { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/compiler.rs:53:46 [INFO] [stderr] | [INFO] [stderr] 53 | &Expression::Literal(ref literal) => match literal { [INFO] [stderr] | ______________________________________________^ [INFO] [stderr] 54 | | &Literal::Map(ref pairs) => { [INFO] [stderr] 55 | | let mut map_instructions = pairs [INFO] [stderr] 56 | | .iter() [INFO] [stderr] ... | [INFO] [stderr] 67 | | _ => vec![Instruction::Push(literal.to_owned())], [INFO] [stderr] 68 | | }, [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] 53 | &Expression::Literal(ref literal) => match *literal { [INFO] [stderr] 54 | Literal::Map(ref pairs) => { [INFO] [stderr] | [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/compiler.rs:108:28 [INFO] [stderr] | [INFO] [stderr] 108 | pub fn compile(statements: &Vec) -> InstructionSequence { [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: change this to: `&[Statement]` [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/exception_handler.rs:31:9 [INFO] [stderr] | [INFO] [stderr] 31 | / match pattern { [INFO] [stderr] 32 | | &Pattern::Number(ref ratio) => ExceptionHandler::match_number(ratio, value), [INFO] [stderr] 33 | | &Pattern::CharString(ref string) => ExceptionHandler::match_string(string, value), [INFO] [stderr] 34 | | &Pattern::Boolean(bool) => ExceptionHandler::match_bool(bool, value), [INFO] [stderr] ... | [INFO] [stderr] 39 | | } [INFO] [stderr] 40 | | } [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] 31 | match *pattern { [INFO] [stderr] 32 | Pattern::Number(ref ratio) => ExceptionHandler::match_number(ratio, value), [INFO] [stderr] 33 | Pattern::CharString(ref string) => ExceptionHandler::match_string(string, value), [INFO] [stderr] 34 | Pattern::Boolean(bool) => ExceptionHandler::match_bool(bool, value), [INFO] [stderr] 35 | Pattern::Map(ref pairs) => ExceptionHandler::match_map(pairs, value), [INFO] [stderr] 36 | Pattern::Identifier(ref name) => ExceptionHandler::match_identifier(name, value), [INFO] [stderr] ... [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/exception_handler.rs:43:37 [INFO] [stderr] | [INFO] [stderr] 43 | fn match_string_match(bindings: &Vec, regex: &Regex, value: &Value) -> MatchedBindings { [INFO] [stderr] | ^^^^^^^^^^^^ help: change this to: `&[String]` [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/exception_handler.rs:44:9 [INFO] [stderr] | [INFO] [stderr] 44 | / if let &Value::CharString(ref char_str) = value { [INFO] [stderr] 45 | | if let Some(mat) = regex.captures(char_str) { [INFO] [stderr] 46 | | let results = bindings [INFO] [stderr] 47 | | .iter() [INFO] [stderr] ... | [INFO] [stderr] 62 | | None [INFO] [stderr] 63 | | } [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] 44 | if let Value::CharString(ref char_str) = *value { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/exception_handler.rs:67:9 [INFO] [stderr] | [INFO] [stderr] 67 | / match value { [INFO] [stderr] 68 | | &Value::Number(ref number) => match ratio.eq(number) { [INFO] [stderr] 69 | | true => Some(BTreeMap::new()), [INFO] [stderr] 70 | | _ => None, [INFO] [stderr] 71 | | }, [INFO] [stderr] 72 | | _ => None, [INFO] [stderr] 73 | | } [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] 67 | match *value { [INFO] [stderr] 68 | Value::Number(ref number) => match ratio.eq(number) { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to match on a boolean expression [INFO] [stderr] --> src/exception_handler.rs:68:43 [INFO] [stderr] | [INFO] [stderr] 68 | &Value::Number(ref number) => match ratio.eq(number) { [INFO] [stderr] | ___________________________________________^ [INFO] [stderr] 69 | | true => Some(BTreeMap::new()), [INFO] [stderr] 70 | | _ => None, [INFO] [stderr] 71 | | }, [INFO] [stderr] | |_____________^ help: consider using an if/else expression: `if ratio.eq(number) { Some(BTreeMap::new()) } else { None }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/exception_handler.rs:76:29 [INFO] [stderr] | [INFO] [stderr] 76 | fn match_string(string: &String, value: &Value) -> MatchedBindings { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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/exception_handler.rs:77:9 [INFO] [stderr] | [INFO] [stderr] 77 | / match value { [INFO] [stderr] 78 | | &Value::CharString(ref str) => match str.eq(string) { [INFO] [stderr] 79 | | true => Some(BTreeMap::new()), [INFO] [stderr] 80 | | _ => None, [INFO] [stderr] 81 | | }, [INFO] [stderr] 82 | | _ => None, [INFO] [stderr] 83 | | } [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] 77 | match *value { [INFO] [stderr] 78 | Value::CharString(ref str) => match str.eq(string) { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to match on a boolean expression [INFO] [stderr] --> src/exception_handler.rs:78:44 [INFO] [stderr] | [INFO] [stderr] 78 | &Value::CharString(ref str) => match str.eq(string) { [INFO] [stderr] | ____________________________________________^ [INFO] [stderr] 79 | | true => Some(BTreeMap::new()), [INFO] [stderr] 80 | | _ => None, [INFO] [stderr] 81 | | }, [INFO] [stderr] | |_____________^ help: consider using an if/else expression: `if str.eq(string) { Some(BTreeMap::new()) } else { None }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/exception_handler.rs:87:9 [INFO] [stderr] | [INFO] [stderr] 87 | / match value { [INFO] [stderr] 88 | | &Value::Boolean(other_bool) => match b == other_bool { [INFO] [stderr] 89 | | true => Some(BTreeMap::new()), [INFO] [stderr] 90 | | _ => None, [INFO] [stderr] 91 | | }, [INFO] [stderr] 92 | | _ => None, [INFO] [stderr] 93 | | } [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] 87 | match *value { [INFO] [stderr] 88 | Value::Boolean(other_bool) => match b == other_bool { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to match on a boolean expression [INFO] [stderr] --> src/exception_handler.rs:88:44 [INFO] [stderr] | [INFO] [stderr] 88 | &Value::Boolean(other_bool) => match b == other_bool { [INFO] [stderr] | ____________________________________________^ [INFO] [stderr] 89 | | true => Some(BTreeMap::new()), [INFO] [stderr] 90 | | _ => None, [INFO] [stderr] 91 | | }, [INFO] [stderr] | |_____________^ help: consider using an if/else expression: `if b == other_bool { Some(BTreeMap::new()) } else { None }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#match_bool [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/exception_handler.rs:96:25 [INFO] [stderr] | [INFO] [stderr] 96 | fn match_map(pairs: &Vec<(Pattern, Pattern)>, value: &Value) -> MatchedBindings { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `&[(Pattern, Pattern)]` [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/exception_handler.rs:97:9 [INFO] [stderr] | [INFO] [stderr] 97 | / match value { [INFO] [stderr] 98 | | &Value::Map(ref btreemap) => { [INFO] [stderr] 99 | | let mut bindings: BTreeMap = BTreeMap::new(); [INFO] [stderr] 100 | | for &(ref key, ref pattern_value) in pairs.iter() { [INFO] [stderr] ... | [INFO] [stderr] 127 | | _ => None, [INFO] [stderr] 128 | | } [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] 97 | match *value { [INFO] [stderr] 98 | Value::Map(ref btreemap) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: redundant pattern matching, consider using `is_none()` [INFO] [stderr] --> src/exception_handler.rs:108:28 [INFO] [stderr] | [INFO] [stderr] 108 | if let None = maybe_nested_bindings { [INFO] [stderr] | _____________________- ^^^^ [INFO] [stderr] 109 | | return None; [INFO] [stderr] 110 | | } [INFO] [stderr] | |_____________________- help: try this: `if maybe_nested_bindings.is_none()` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::redundant_pattern_matching)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/exception_handler.rs:131:31 [INFO] [stderr] | [INFO] [stderr] 131 | fn match_identifier(name: &String, value: &Value) -> MatchedBindings { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-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/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:62:310 [INFO] [stderr] | [INFO] [stderr] 62 | fn parse_statements < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] { 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 = parse___ ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_statement ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } } [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/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:90:330 [INFO] [stderr] | [INFO] [stderr] 90 | fn parse_callArguments < '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 = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_expression ( __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 , args ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:116:648 [INFO] [stderr] | [INFO] [stderr] 116 | fn parse_accessExpression < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = { let seq_res = parse_primary ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , target ) => { { let seq_res = { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = parse_propertyAccess ( __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 , repeat_value ) } else { Failed } } ; match seq_res { Matched ( __pos , properties ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:143:695 [INFO] [stderr] | [INFO] [stderr] 143 | fn parse_digits < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => 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 } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unit_arg)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 143 | fn parse_digits < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => 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 } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: length comparison to one [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:143:738 [INFO] [stderr] | [INFO] [stderr] 143 | fn parse_digits < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let seq_res = { let str_start = __pos ; match { let mut __repeat_pos = __pos ; let mut repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => 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 } } { Matched ( newpos , _ ) => { Matched ( newpos , & __input [ str_start .. newpos ] ) } , Failed => Failed , } } ; match seq_res { Matched ( __pos , c ) => { { let seq_res = parse___ ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:165:317 [INFO] [stderr] | [INFO] [stderr] 165 | fn parse_functionArgumentList < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] { 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 = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = parse_identifier ( __input , __state , __pos ) ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; repeat_value . push ( value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , repeat_value ) } } [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/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:175:342 [INFO] [stderr] | [INFO] [stderr] 175 | fn parse_keyPairList < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<(Expression, Expression)> > { # ! [ 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 = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = { let seq_res = parse_expression ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , key ) => { { let seq_res = parse_fatArrow ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_expression ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , value ) => { Matched ( __pos , { (key, value) } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; 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 , pairs ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:187:340 [INFO] [stderr] | [INFO] [stderr] 187 | fn parse_patternPairList < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<(Pattern, Pattern)> > { # ! [ 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 = parse_comma ( __input , __state , __pos ) ; match sep_res { Matched ( newpos , _ ) => { newpos } , Failed => break , } } else { __pos } ; let step_res = { let seq_res = parse_patternKey ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , key ) => { { let seq_res = parse_fatArrow ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , _ ) => { { let seq_res = parse_pattern ( __input , __state , __pos ) ; match seq_res { Matched ( __pos , value ) => { Matched ( __pos , { (key, value) } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; 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 , pairs ) => { Matched ( __pos , { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!repeat_value.is_empty()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#len_zero [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:243:733 [INFO] [stderr] | [INFO] [stderr] 243 | fn parse___ < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[ \n]" ) , } } else { __state . mark_failure ( __pos , "[ \n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_comment ( __input , __state , __pos ) } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 243 | fn parse___ < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_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' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[ \n]" ) , } } else { __state . mark_failure ( __pos , "[ \n]" ) } ; match step_res { Matched ( newpos , value ) => { __repeat_pos = newpos ; } , Failed => { break ; } } } Matched ( __repeat_pos , ( ) ) } ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => parse_comment ( __input , __state , __pos ) } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:308 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:465 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:622 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:773 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:247:926 [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [INFO] [stderr] | ^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg [INFO] [stderr] help: if you intended to pass a unit value, use a unit literal instead [INFO] [stderr] | [INFO] [stderr] 247 | fn parse_keywords < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] { let choice_res = parse_let ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "fn" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = slice_eq ( __input , __state , __pos , "do" ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_end ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let choice_res = parse_raise ( __input , __state , __pos ) ; match choice_res { Matched ( __pos , __value ) => Matched ( __pos , () ) , Failed => parse_rescue ( __input , __state , __pos ) } } } } } } } } } } } [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] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:492 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( input , & mut state , 0 ) { Matched ( pos , value ) => { if pos == input . len ( ) { return Ok ( value ) } } _ => { } } let ( line , col ) = pos_to_line ( input , state . max_err_pos ) ; Err ( ParseError { line : line , column : col , offset : state . max_err_pos , expected : state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_lifetimes)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:664 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( 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_statements ( 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: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:991 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( input , & mut state , 0 ) { Matched ( pos , value ) => { if pos == input . len ( ) { return Ok ( value ) } } _ => { } } let ( line , col ) = pos_to_line ( input , state . max_err_pos ) ; Err ( ParseError { line : line , column : col , offset : state . max_err_pos , expected : state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:1159 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( 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_expression ( input , & mut state , 0 ) { if pos == input . len ( ) { return Ok ( value ) } }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] [INFO] [stderr] warning: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:1486 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( input , & mut state , 0 ) { Matched ( pos , value ) => { if pos == input . len ( ) { return Ok ( value ) } } _ => { } } let ( line , col ) = pos_to_line ( input , state . max_err_pos ) ; Err ( ParseError { line : line , column : col , offset : state . max_err_pos , expected : state . expected , } ) } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> /opt/crater/target/debug/build/exceptional-f1b18d2b49a74a1d/out/exceptional-grammar.rs:277:1648 [INFO] [stderr] | [INFO] [stderr] 277 | fn parse_eolChar < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < () > { # ! [ allow ( non_snake_case , unused ) ] if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) , } } else { __state . mark_failure ( __pos , "[\n\r\u{2028}\u{2029}]" ) } } pub fn statements < 'input > ( input : & 'input str ) -> ParseResult < Vec > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_statements ( 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 , } ) } pub fn expression < 'input > ( input : & 'input str ) -> ParseResult < Expression > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_expression ( 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 , } ) } pub fn literal < 'input > ( input : & 'input str ) -> ParseResult < Literal > { # ! [ allow ( non_snake_case , unused ) ] let mut state = ParseState :: new ( ) ; match parse_literal ( 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_literal ( input , & mut state , 0 ) { if pos == input . len ( ) { return Ok ( value ) } }` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] [INFO] [stderr] warning: transmute from a type (`*const for<'r> fn(&'r mut vm::Vm) -> std::vec::Vec`) to the type that it points to (`for<'r> fn(&'r mut vm::Vm) -> std::vec::Vec`) [INFO] [stderr] --> src/instructions.rs:35:24 [INFO] [stderr] | [INFO] [stderr] 35 | let func = transmute:: InstructionSequence>(self.function); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::crosspointer_transmute)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#crosspointer_transmute [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/native.rs:31:9 [INFO] [stderr] | [INFO] [stderr] 31 | / match self { [INFO] [stderr] 32 | | &mut FileDescriptor::TcpStream(ref mut s) => match s.read_to_string(&mut buffer) { [INFO] [stderr] 33 | | Err(_) => return Err("can't read on this file descriptor".to_owned()), [INFO] [stderr] 34 | | Ok(_) => Ok(buffer), [INFO] [stderr] 35 | | }, [INFO] [stderr] 36 | | _ => Err("can't read on this file descriptor".to_owned()), [INFO] [stderr] 37 | | } [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] 31 | match *self { [INFO] [stderr] 32 | FileDescriptor::TcpStream(ref mut s) => match s.read_to_string(&mut buffer) { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/native.rs:41:9 [INFO] [stderr] | [INFO] [stderr] 41 | / match self { [INFO] [stderr] 42 | | &mut FileDescriptor::TcpStream(ref mut s) => s [INFO] [stderr] 43 | | .write(string.as_bytes()) [INFO] [stderr] 44 | | .or_else(|e| Err(format!("couldn't write to file descriptor: {:?}", e))), [INFO] [stderr] 45 | | _ => Err("can't write to this file descriptor".to_owned()), [INFO] [stderr] 46 | | } [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] 41 | match *self { [INFO] [stderr] 42 | FileDescriptor::TcpStream(ref mut s) => s [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/native.rs:72:9 [INFO] [stderr] | [INFO] [stderr] 72 | / match self { [INFO] [stderr] 73 | | &FileDescriptor::File(ref f) => unsafe { [INFO] [stderr] 74 | | FileDescriptor::File(File::from_raw_fd(f.as_raw_fd())) [INFO] [stderr] 75 | | }, [INFO] [stderr] ... | [INFO] [stderr] 81 | | }, [INFO] [stderr] 82 | | } [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] 72 | match *self { [INFO] [stderr] 73 | FileDescriptor::File(ref f) => unsafe { [INFO] [stderr] 74 | FileDescriptor::File(File::from_raw_fd(f.as_raw_fd())) [INFO] [stderr] 75 | }, [INFO] [stderr] 76 | FileDescriptor::TcpStream(ref t) => unsafe { [INFO] [stderr] 77 | FileDescriptor::TcpStream(TcpStream::from_raw_fd(t.as_raw_fd())) [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: redundant pattern matching, consider using `is_ok()` [INFO] [stderr] --> src/native.rs:106:12 [INFO] [stderr] | [INFO] [stderr] 106 | if let Ok(_) = file.read_to_string(&mut contents) { [INFO] [stderr] | _____- ^^^^^ [INFO] [stderr] 107 | | return Ok(contents); [INFO] [stderr] 108 | | } else { [INFO] [stderr] 109 | | Err("Can't read file".to_owned()) [INFO] [stderr] 110 | | } [INFO] [stderr] | |_____- help: try this: `if file.read_to_string(&mut contents).is_ok()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/native.rs:129:30 [INFO] [stderr] | [INFO] [stderr] 129 | fn write_file_contents(path: &String, content: &String) -> Result<(), String> { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/native.rs:129:48 [INFO] [stderr] | [INFO] [stderr] 129 | fn write_file_contents(path: &String, content: &String) -> Result<(), String> { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: redundant pattern matching, consider using `is_ok()` [INFO] [stderr] --> src/native.rs:135:12 [INFO] [stderr] | [INFO] [stderr] 135 | if let Ok(_) = file.write_all(content.as_bytes()) { [INFO] [stderr] | _____- ^^^^^ [INFO] [stderr] 136 | | Ok(()) [INFO] [stderr] 137 | | } else { [INFO] [stderr] 138 | | Err("Can't write file".to_owned()) [INFO] [stderr] 139 | | } [INFO] [stderr] | |_____- help: try this: `if file.write_all(content.as_bytes()).is_ok()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching [INFO] [stderr] [INFO] [stderr] warning: use of `ok_or` followed by a function call [INFO] [stderr] --> src/native.rs:248:18 [INFO] [stderr] | [INFO] [stderr] 248 | .ok_or("socket not found".to_owned()) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `ok_or_else(|| "socket not found".to_owned())` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::or_fun_call)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/native.rs:250:21 [INFO] [stderr] | [INFO] [stderr] 250 | / if let &FileDescriptor::TcpListener(ref l) = descriptor { [INFO] [stderr] 251 | | Ok(l) [INFO] [stderr] 252 | | } else { [INFO] [stderr] 253 | | Err("socket is not a socket".to_owned()) [INFO] [stderr] 254 | | } [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] 250 | if let FileDescriptor::TcpListener(ref l) = *descriptor { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: use of `ok_or` followed by a function call [INFO] [stderr] --> src/native.rs:289:18 [INFO] [stderr] | [INFO] [stderr] 289 | .ok_or("file descriptor not found".to_owned()) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `ok_or_else(|| "file descriptor not found".to_owned())` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call [INFO] [stderr] [INFO] [stderr] warning: use of `ok_or` followed by a function call [INFO] [stderr] --> src/native.rs:317:18 [INFO] [stderr] | [INFO] [stderr] 317 | .ok_or("file descriptor not found".to_owned()) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `ok_or_else(|| "file descriptor not found".to_owned())` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call [INFO] [stderr] [INFO] [stderr] warning: this let-binding has unit value. Consider omitting `let _socket_fd =` [INFO] [stderr] --> src/native.rs:574:9 [INFO] [stderr] | [INFO] [stderr] 574 | / let _socket_fd = match vm.pop() { [INFO] [stderr] 575 | | Some(Value::Map(map)) => { [INFO] [stderr] 576 | | match map.borrow().get(&v_string("socket.result")) { [INFO] [stderr] 577 | | Some(&Value::Number(_)) => {} // All good [INFO] [stderr] ... | [INFO] [stderr] 581 | | _ => panic!("expected result to be a map"), [INFO] [stderr] 582 | | }; [INFO] [stderr] | |__________^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::let_unit_value)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value [INFO] [stderr] [INFO] [stderr] warning: this let-binding has unit value. Consider omitting `let _socket_fd =` [INFO] [stderr] --> src/native.rs:593:9 [INFO] [stderr] | [INFO] [stderr] 593 | / let _socket_fd = match vm.pop() { [INFO] [stderr] 594 | | Some(Value::Map(map)) => { [INFO] [stderr] 595 | | match map.borrow().get(&v_string("socket.result")) { [INFO] [stderr] 596 | | Some(&Value::Number(_)) => {} // All good [INFO] [stderr] ... | [INFO] [stderr] 600 | | _ => panic!("expected result to be a map"), [INFO] [stderr] 601 | | }; [INFO] [stderr] | |__________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value [INFO] [stderr] [INFO] [stderr] warning: casting i32 to i64 may become silently lossy if types change [INFO] [stderr] --> src/native.rs:616:22 [INFO] [stderr] | [INFO] [stderr] 616 | v_number(listener.as_raw_fd() as i64, 1), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i64::from(listener.as_raw_fd())` [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] error: handle written amount returned or use `Write::write_all` instead [INFO] [stderr] --> src/native.rs:632:9 [INFO] [stderr] | [INFO] [stderr] 632 | connector.write("foo".as_bytes()).expect("write failed"); [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] warning: calling `as_bytes()` on a string literal [INFO] [stderr] --> src/native.rs:632:25 [INFO] [stderr] | [INFO] [stderr] 632 | connector.write("foo".as_bytes()).expect("write failed"); [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"foo"` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::string_lit_as_bytes)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#string_lit_as_bytes [INFO] [stderr] [INFO] [stderr] warning: casting i32 to i64 may become silently lossy if types change [INFO] [stderr] --> src/native.rs:639:52 [INFO] [stderr] | [INFO] [stderr] 639 | vm.local_assign(&"fd".to_owned(), v_number(socket.as_raw_fd() as i64, 1)); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i64::from(socket.as_raw_fd())` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless [INFO] [stderr] [INFO] [stderr] warning: casting i32 to i64 may become silently lossy if types change [INFO] [stderr] --> src/native.rs:659:52 [INFO] [stderr] | [INFO] [stderr] 659 | vm.local_assign(&"fd".to_owned(), v_number(socket.as_raw_fd() as i64, 1)); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i64::from(socket.as_raw_fd())` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `Box>`. Consider using just `Vec` [INFO] [stderr] --> src/value.rs:16:16 [INFO] [stderr] | [INFO] [stderr] 16 | Closure(Rc>>, Rc), [INFO] [stderr] | ^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: `Vec` is already on the heap, `Box>` makes an extra allocation. [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#box_vec [INFO] [stderr] [INFO] [stderr] warning: useless use of `format!` [INFO] [stderr] --> src/value.rs:37:21 [INFO] [stderr] | [INFO] [stderr] 37 | Err(format!("Subtraction of closures is not supported")) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using .to_string(): `"Subtraction of closures is not supported".to_string()` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::useless_format)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_format [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/value.rs:100:75 [INFO] [stderr] | [INFO] [stderr] 100 | | (&Value::Number(ref ratio), Value::Boolean(ref boolean)) => match boolean { [INFO] [stderr] | ___________________________________________________________________________^ [INFO] [stderr] 101 | | &true => Ok(Value::Number(ratio.clone())), [INFO] [stderr] 102 | | &false => Ok(Value::Number(Ratio::new(BigInt::zero(), BigInt::one()))), [INFO] [stderr] 103 | | }, [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] 100 | | (&Value::Number(ref ratio), Value::Boolean(ref boolean)) => match *boolean { [INFO] [stderr] 101 | true => Ok(Value::Number(ratio.clone())), [INFO] [stderr] 102 | false => Ok(Value::Number(Ratio::new(BigInt::zero(), BigInt::one()))), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/value.rs:105:77 [INFO] [stderr] | [INFO] [stderr] 105 | | (&Value::Boolean(ref boolean), Value::CharString(ref str)) => match boolean { [INFO] [stderr] | _____________________________________________________________________________^ [INFO] [stderr] 106 | | &true => Ok(Value::CharString(str.clone())), [INFO] [stderr] 107 | | &false => Ok(Value::CharString("".to_owned())), [INFO] [stderr] 108 | | }, [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] 105 | | (&Value::Boolean(ref boolean), Value::CharString(ref str)) => match *boolean { [INFO] [stderr] 106 | true => Ok(Value::CharString(str.clone())), [INFO] [stderr] 107 | false => Ok(Value::CharString("".to_owned())), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 29 [INFO] [stderr] --> src/value.rs:246:5 [INFO] [stderr] | [INFO] [stderr] 246 | / fn mul() { [INFO] [stderr] 247 | | // Numbers * Number [INFO] [stderr] 248 | | assert_eq!(Ok(v_number(4, 1)), v_number(8, 1).mul(v_number(1, 2))); [INFO] [stderr] 249 | | // Number * CharString [INFO] [stderr] ... | [INFO] [stderr] 316 | | // Map * Map [INFO] [stderr] 317 | | } [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: the function has a cyclomatic complexity of 45 [INFO] [stderr] --> src/value.rs:419:5 [INFO] [stderr] | [INFO] [stderr] 419 | / fn gt_and_lt() { [INFO] [stderr] 420 | | // Number > Number [INFO] [stderr] 421 | | assert_eq!(Ok(v_bool(true)), v_number(2, 1).val_gt(&v_number(1, 1))); [INFO] [stderr] 422 | | assert_eq!(Ok(v_bool(false)), v_number(1, 1).val_gt(&v_number(1, 1))); [INFO] [stderr] ... | [INFO] [stderr] 524 | | ); [INFO] [stderr] 525 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = help: you could split it up into multiple smaller functions [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cyclomatic_complexity [INFO] [stderr] [INFO] [stderr] warning: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> src/vm.rs:73:5 [INFO] [stderr] | [INFO] [stderr] 73 | / pub fn run<'b>(&'b mut self) { [INFO] [stderr] 74 | | loop { [INFO] [stderr] 75 | | let insn_result = Vm::next_instruction(self); [INFO] [stderr] 76 | | let instruction; [INFO] [stderr] ... | [INFO] [stderr] 244 | | } [INFO] [stderr] 245 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes [INFO] [stderr] [INFO] [stderr] warning: useless use of `format!` [INFO] [stderr] --> src/vm.rs:112:37 [INFO] [stderr] | [INFO] [stderr] 112 | None => Err(format!("expected a closure, got None")), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using .to_string(): `"expected a closure, got None".to_string()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_format [INFO] [stderr] [INFO] [stderr] warning: identical conversion [INFO] [stderr] --> src/vm.rs:145:31 [INFO] [stderr] | [INFO] [stderr] 145 | let map = (0..size) [INFO] [stderr] | _______________________________^ [INFO] [stderr] 146 | | .into_iter() [INFO] [stderr] | |____________________________________^ help: consider removing `.into_iter()`: `(0..size)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::identity_conversion)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#identity_conversion [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/vm.rs:255:35 [INFO] [stderr] | [INFO] [stderr] 255 | pub fn fetch(&mut self, name: &String) -> Option { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/vm.rs:259:42 [INFO] [stderr] | [INFO] [stderr] 259 | pub fn local_assign(&mut self, name: &String, value: Value) { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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/vm.rs:334:9 [INFO] [stderr] | [INFO] [stderr] 334 | / match literal { [INFO] [stderr] 335 | | &Literal::Number(ref num) => Value::Number(num.to_owned()), [INFO] [stderr] 336 | | &Literal::CharString(ref str) => Value::CharString(str.to_string()), [INFO] [stderr] 337 | | &Literal::Fn(ref args, ref statements) => { [INFO] [stderr] ... | [INFO] [stderr] 343 | | _ => panic!("not implemented literal_to_value for {:?}", literal), [INFO] [stderr] 344 | | } [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] 334 | match *literal { [INFO] [stderr] 335 | Literal::Number(ref num) => Value::Number(num.to_owned()), [INFO] [stderr] 336 | Literal::CharString(ref str) => Value::CharString(str.to_string()), [INFO] [stderr] 337 | Literal::Fn(ref args, ref statements) => { [INFO] [stderr] 338 | // Statements should be compiled ahead of time [INFO] [stderr] 339 | let closure = Closure::new(Rc::new(compile(&statements)), top_bindings); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] error: handle written amount returned or use `Write::write_all` instead [INFO] [stderr] --> src/vm.rs:538:9 [INFO] [stderr] | [INFO] [stderr] 538 | buffer.write(b"file content").unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/main.rs:26:17 [INFO] [stderr] | [INFO] [stderr] 26 | fn exec(source: &String) { [INFO] [stderr] | ^^^^^^^ help: change this to: `&str` [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: use of `ok_or` followed by a function call [INFO] [stderr] --> src/main.rs:41:10 [INFO] [stderr] | [INFO] [stderr] 41 | .ok_or("No path given, stopping".to_string()) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `ok_or_else(|| "No path given, stopping".to_string())` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call [INFO] [stderr] [INFO] [stderr] error: aborting due to 2 previous errors [INFO] [stderr] [INFO] [stderr] error: Could not compile `exceptional`. [INFO] [stderr] [INFO] [stderr] To learn more, run the command again with --verbose. [INFO] running `"docker" "inspect" "3ecec242d5e6e99cd36ec479059705083c81e5d24cac7eb1e350ea4ebc4392c7"` [INFO] running `"docker" "rm" "-f" "3ecec242d5e6e99cd36ec479059705083c81e5d24cac7eb1e350ea4ebc4392c7"` [INFO] [stdout] 3ecec242d5e6e99cd36ec479059705083c81e5d24cac7eb1e350ea4ebc4392c7