[INFO] updating cached repository mthom/rusty-wam [INFO] running `"git" "fetch" "--all"` [INFO] [stdout] Fetching origin [INFO] [stderr] From git://github.com/mthom/rusty-wam [INFO] [stderr] * branch HEAD -> FETCH_HEAD [INFO] running `"git" "clone" "work/cache/sources/gh/mthom/rusty-wam" "work/ex/clippy-test-run/sources/stable/gh/mthom/rusty-wam"` [INFO] [stderr] Cloning into 'work/ex/clippy-test-run/sources/stable/gh/mthom/rusty-wam'... [INFO] [stderr] done. [INFO] running `"git" "clone" "work/cache/sources/gh/mthom/rusty-wam" "work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/gh/mthom/rusty-wam"` [INFO] [stderr] Cloning into 'work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/gh/mthom/rusty-wam'... [INFO] [stderr] done. [INFO] running `"git" "rev-parse" "HEAD"` [INFO] [stdout] 2b774f3041c9313ca344c693e2ea7d146d4c365e [INFO] sha for GitHub repo mthom/rusty-wam: 2b774f3041c9313ca344c693e2ea7d146d4c365e [INFO] validating manifest of mthom/rusty-wam 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 mthom/rusty-wam 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 mthom/rusty-wam [INFO] finished frobbing mthom/rusty-wam [INFO] frobbed toml for mthom/rusty-wam written to work/ex/clippy-test-run/sources/stable/gh/mthom/rusty-wam/Cargo.toml [INFO] started frobbing mthom/rusty-wam [INFO] finished frobbing mthom/rusty-wam [INFO] frobbed toml for mthom/rusty-wam written to work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/gh/mthom/rusty-wam/Cargo.toml [INFO] crate mthom/rusty-wam 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 mthom/rusty-wam 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/mthom/rusty-wam:/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] 2e7cb173d45722313f29266dc4ba99c24af9029495998039e005a15693d9a943 [INFO] running `"docker" "start" "-a" "2e7cb173d45722313f29266dc4ba99c24af9029495998039e005a15693d9a943"` [INFO] [stderr] Checking downcast v0.9.1 [INFO] [stderr] Checking termion v1.5.1 [INFO] [stderr] Checking prolog_parser v0.7.18 [INFO] [stderr] Checking rusty-wam v0.7.16 (/opt/crater/workdir) [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/prolog/instructions.rs:1319:13 [INFO] [stderr] | [INFO] [stderr] 1319 | last_term_arity: last_term_arity, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `last_term_arity` [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/prolog/and_stack.rs:18:13 [INFO] [stderr] | [INFO] [stderr] 18 | e: e, [INFO] [stderr] | ^^^^ help: replace it with: `e` [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/prolog/and_stack.rs:19:13 [INFO] [stderr] | [INFO] [stderr] 19 | cp: cp, [INFO] [stderr] | ^^^^^^ help: replace it with: `cp` [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/prolog/machine/machine_state.rs:42:25 [INFO] [stderr] | [INFO] [stderr] 42 | DuplicateTerm { state: state } [INFO] [stderr] | ^^^^^^^^^^^^ help: replace it with: `state` [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: 5th binding whose name is just one char [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1143:21 [INFO] [stderr] | [INFO] [stderr] 1143 | o => self.p += o [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::many_single_char_names)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names [INFO] [stderr] [INFO] [stderr] warning: 5th binding whose name is just one char [INFO] [stderr] --> src/prolog/write.rs:189:57 [INFO] [stderr] | [INFO] [stderr] 189 | &IndexingInstruction::SwitchOnTerm(v, c, l, s) => [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names [INFO] [stderr] [INFO] [stderr] warning: using `write!()` with a format string that ends in a single newline, consider using `writeln!()` instead [INFO] [stderr] --> src/prolog/write.rs:354:13 [INFO] [stderr] | [INFO] [stderr] 354 | write!(stdout(), ".\n").unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::write_with_newline)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#write_with_newline [INFO] [stderr] [INFO] [stderr] warning: redundant field names in struct initialization [INFO] [stderr] --> src/prolog/instructions.rs:1319:13 [INFO] [stderr] | [INFO] [stderr] 1319 | last_term_arity: last_term_arity, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `last_term_arity` [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/prolog/and_stack.rs:18:13 [INFO] [stderr] | [INFO] [stderr] 18 | e: e, [INFO] [stderr] | ^^^^ help: replace it with: `e` [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/prolog/and_stack.rs:19:13 [INFO] [stderr] | [INFO] [stderr] 19 | cp: cp, [INFO] [stderr] | ^^^^^^ help: replace it with: `cp` [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/prolog/machine/machine_state.rs:42:25 [INFO] [stderr] | [INFO] [stderr] 42 | DuplicateTerm { state: state } [INFO] [stderr] | ^^^^^^^^^^^^ help: replace it with: `state` [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: 5th binding whose name is just one char [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1143:21 [INFO] [stderr] | [INFO] [stderr] 1143 | o => self.p += o [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::many_single_char_names)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names [INFO] [stderr] [INFO] [stderr] warning: 5th binding whose name is just one char [INFO] [stderr] --> src/prolog/write.rs:189:57 [INFO] [stderr] | [INFO] [stderr] 189 | &IndexingInstruction::SwitchOnTerm(v, c, l, s) => [INFO] [stderr] | ^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names [INFO] [stderr] [INFO] [stderr] warning: using `write!()` with a format string that ends in a single newline, consider using `writeln!()` instead [INFO] [stderr] --> src/prolog/write.rs:354:13 [INFO] [stderr] | [INFO] [stderr] 354 | write!(stdout(), ".\n").unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::write_with_newline)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#write_with_newline [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/instructions.rs:1333:9 [INFO] [stderr] | [INFO] [stderr] 1333 | return false; [INFO] [stderr] | ^^^^^^^^^^^^^ help: remove `return` as shown: `false` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_return)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/toplevel.rs:242:14 [INFO] [stderr] | [INFO] [stderr] 242 | _ => return Err(ParserError::InconsistentEntry) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `Err(ParserError::InconsistentEntry)` [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: All variants have the same postfix: `List` [INFO] [stderr] --> src/prolog/machine/machine_errors.rs:216:1 [INFO] [stderr] | [INFO] [stderr] 216 | / pub(super) enum CycleSearchResult { [INFO] [stderr] 217 | | EmptyList, [INFO] [stderr] 218 | | NotList, [INFO] [stderr] 219 | | PartialList(usize, usize), // the list length (up to max), and an offset into the heap. [INFO] [stderr] 220 | | ProperList(usize), // the list length. [INFO] [stderr] 221 | | UntouchedList(usize) // the address of an uniterated Addr::Lis(address). [INFO] [stderr] 222 | | } [INFO] [stderr] | |_^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::enum_variant_names)] on by default [INFO] [stderr] = help: remove the postfixes and use full paths to the variants instead of glob imports [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names [INFO] [stderr] [INFO] [stderr] warning: this `else { if .. }` block can be collapsed [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1618:28 [INFO] [stderr] | [INFO] [stderr] 1618 | } else { [INFO] [stderr] | ____________________________^ [INFO] [stderr] 1619 | | if s2.is_expandable() { [INFO] [stderr] 1620 | | Ordering::Less [INFO] [stderr] 1621 | | } else { [INFO] [stderr] 1622 | | s1.cmp(&s2) [INFO] [stderr] 1623 | | } [INFO] [stderr] 1624 | | }, [INFO] [stderr] | |_____________________^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::collapsible_if)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 1618 | } else if s2.is_expandable() { [INFO] [stderr] 1619 | Ordering::Less [INFO] [stderr] 1620 | } else { [INFO] [stderr] 1621 | s1.cmp(&s2) [INFO] [stderr] 1622 | }, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/machine/mod.rs:105:9 [INFO] [stderr] | [INFO] [stderr] 105 | return (0, 0); [INFO] [stderr] | ^^^^^^^^^^^^^^ help: remove `return` as shown: `(0, 0)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/codegen.rs:170:21 [INFO] [stderr] | [INFO] [stderr] 170 | / if self.marker.is_unbound(var.clone()) { [INFO] [stderr] 171 | | if term_loc != GenContext::Head { [INFO] [stderr] 172 | | self.marker.mark_reserved_var(var.clone(), lvl, cell, term_loc, [INFO] [stderr] 173 | | &mut target, perm_v!(1), false); [INFO] [stderr] 174 | | continue; [INFO] [stderr] 175 | | } [INFO] [stderr] 176 | | } [INFO] [stderr] | |_____________________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 170 | if self.marker.is_unbound(var.clone()) && term_loc != GenContext::Head { [INFO] [stderr] 171 | self.marker.mark_reserved_var(var.clone(), lvl, cell, term_loc, [INFO] [stderr] 172 | &mut target, perm_v!(1), false); [INFO] [stderr] 173 | continue; [INFO] [stderr] 174 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/debray_allocator.rs:55:21 [INFO] [stderr] | [INFO] [stderr] 55 | / if !self.is_in_use(reg) { [INFO] [stderr] 56 | | if !tvd.no_use_set.contains(®) { [INFO] [stderr] 57 | | result = reg; [INFO] [stderr] 58 | | break; [INFO] [stderr] 59 | | } [INFO] [stderr] 60 | | } [INFO] [stderr] | |_____________________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 55 | if !self.is_in_use(reg) && !tvd.no_use_set.contains(®) { [INFO] [stderr] 56 | result = reg; [INFO] [stderr] 57 | break; [INFO] [stderr] 58 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/debray_allocator.rs:82:21 [INFO] [stderr] | [INFO] [stderr] 82 | / if !self.is_in_use(reg) { [INFO] [stderr] 83 | | if !tvd.no_use_set.contains(®) { [INFO] [stderr] 84 | | if !tvd.conflict_set.contains(®) { [INFO] [stderr] 85 | | result = reg; [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#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 82 | if !self.is_in_use(reg) && !tvd.no_use_set.contains(®) { [INFO] [stderr] 83 | if !tvd.conflict_set.contains(®) { [INFO] [stderr] 84 | result = reg; [INFO] [stderr] 85 | break; [INFO] [stderr] 86 | } [INFO] [stderr] 87 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/debray_allocator.rs:83:25 [INFO] [stderr] | [INFO] [stderr] 83 | / if !tvd.no_use_set.contains(®) { [INFO] [stderr] 84 | | if !tvd.conflict_set.contains(®) { [INFO] [stderr] 85 | | result = reg; [INFO] [stderr] 86 | | break; [INFO] [stderr] 87 | | } [INFO] [stderr] 88 | | } [INFO] [stderr] | |_________________________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 83 | if !tvd.no_use_set.contains(®) && !tvd.conflict_set.contains(®) { [INFO] [stderr] 84 | result = reg; [INFO] [stderr] 85 | break; [INFO] [stderr] 86 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/fixtures.rs:55:29 [INFO] [stderr] | [INFO] [stderr] 55 | / if cn_u == cn_t && *u != ***t { [INFO] [stderr] 56 | | if !t_data.uses_reg(reg) { [INFO] [stderr] 57 | | t_data.no_use_set.insert(reg); [INFO] [stderr] 58 | | } [INFO] [stderr] 59 | | } [INFO] [stderr] | |_____________________________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 55 | if cn_u == cn_t && *u != ***t && !t_data.uses_reg(reg) { [INFO] [stderr] 56 | t_data.no_use_set.insert(reg); [INFO] [stderr] 57 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/heap_print.rs:180:9 [INFO] [stderr] | [INFO] [stderr] 180 | / return match iter.next() { [INFO] [stderr] 181 | | None => true, [INFO] [stderr] 182 | | Some('*') => false, // if we start with comment token, we must quote. [INFO] [stderr] 183 | | Some(c) => if graphic_token_char!(c) { [INFO] [stderr] ... | [INFO] [stderr] 187 | | } [INFO] [stderr] 188 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] help: remove `return` as shown [INFO] [stderr] | [INFO] [stderr] 180 | match iter.next() { [INFO] [stderr] 181 | None => true, [INFO] [stderr] 182 | Some('*') => false, // if we start with comment token, we must quote. [INFO] [stderr] 183 | Some(c) => if graphic_token_char!(c) { [INFO] [stderr] 184 | iter.all(|c| graphic_token_char!(c)) [INFO] [stderr] 185 | } else { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/heap_print.rs:190:9 [INFO] [stderr] | [INFO] [stderr] 190 | / return match iter.next() { [INFO] [stderr] 191 | | None => false, [INFO] [stderr] 192 | | Some(c) => if graphic_token_char!(c) { [INFO] [stderr] 193 | | iter.all(|c| graphic_token_char!(c)) [INFO] [stderr] ... | [INFO] [stderr] 196 | | } [INFO] [stderr] 197 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] help: remove `return` as shown [INFO] [stderr] | [INFO] [stderr] 190 | match iter.next() { [INFO] [stderr] 191 | None => false, [INFO] [stderr] 192 | Some(c) => if graphic_token_char!(c) { [INFO] [stderr] 193 | iter.all(|c| graphic_token_char!(c)) [INFO] [stderr] 194 | } else { [INFO] [stderr] 195 | false [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/heap_print.rs:344:21 [INFO] [stderr] | [INFO] [stderr] 344 | return iter.next(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `iter.next()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/heap_print.rs:351:21 [INFO] [stderr] | [INFO] [stderr] 351 | return None; [INFO] [stderr] | ^^^^^^^^^^^^ help: remove `return` as shown: `None` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/instructions.rs:1333:9 [INFO] [stderr] | [INFO] [stderr] 1333 | return false; [INFO] [stderr] | ^^^^^^^^^^^^^ help: remove `return` as shown: `false` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_return)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/toplevel.rs:242:14 [INFO] [stderr] | [INFO] [stderr] 242 | _ => return Err(ParserError::InconsistentEntry) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `Err(ParserError::InconsistentEntry)` [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: All variants have the same postfix: `List` [INFO] [stderr] --> src/prolog/machine/machine_errors.rs:216:1 [INFO] [stderr] | [INFO] [stderr] 216 | / pub(super) enum CycleSearchResult { [INFO] [stderr] 217 | | EmptyList, [INFO] [stderr] 218 | | NotList, [INFO] [stderr] 219 | | PartialList(usize, usize), // the list length (up to max), and an offset into the heap. [INFO] [stderr] 220 | | ProperList(usize), // the list length. [INFO] [stderr] 221 | | UntouchedList(usize) // the address of an uniterated Addr::Lis(address). [INFO] [stderr] 222 | | } [INFO] [stderr] | |_^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::enum_variant_names)] on by default [INFO] [stderr] = help: remove the postfixes and use full paths to the variants instead of glob imports [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names [INFO] [stderr] [INFO] [stderr] warning: this `else { if .. }` block can be collapsed [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1618:28 [INFO] [stderr] | [INFO] [stderr] 1618 | } else { [INFO] [stderr] | ____________________________^ [INFO] [stderr] 1619 | | if s2.is_expandable() { [INFO] [stderr] 1620 | | Ordering::Less [INFO] [stderr] 1621 | | } else { [INFO] [stderr] 1622 | | s1.cmp(&s2) [INFO] [stderr] 1623 | | } [INFO] [stderr] 1624 | | }, [INFO] [stderr] | |_____________________^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::collapsible_if)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 1618 | } else if s2.is_expandable() { [INFO] [stderr] 1619 | Ordering::Less [INFO] [stderr] 1620 | } else { [INFO] [stderr] 1621 | s1.cmp(&s2) [INFO] [stderr] 1622 | }, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/machine/mod.rs:105:9 [INFO] [stderr] | [INFO] [stderr] 105 | return (0, 0); [INFO] [stderr] | ^^^^^^^^^^^^^^ help: remove `return` as shown: `(0, 0)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/codegen.rs:170:21 [INFO] [stderr] | [INFO] [stderr] 170 | / if self.marker.is_unbound(var.clone()) { [INFO] [stderr] 171 | | if term_loc != GenContext::Head { [INFO] [stderr] 172 | | self.marker.mark_reserved_var(var.clone(), lvl, cell, term_loc, [INFO] [stderr] 173 | | &mut target, perm_v!(1), false); [INFO] [stderr] 174 | | continue; [INFO] [stderr] 175 | | } [INFO] [stderr] 176 | | } [INFO] [stderr] | |_____________________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 170 | if self.marker.is_unbound(var.clone()) && term_loc != GenContext::Head { [INFO] [stderr] 171 | self.marker.mark_reserved_var(var.clone(), lvl, cell, term_loc, [INFO] [stderr] 172 | &mut target, perm_v!(1), false); [INFO] [stderr] 173 | continue; [INFO] [stderr] 174 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/debray_allocator.rs:55:21 [INFO] [stderr] | [INFO] [stderr] 55 | / if !self.is_in_use(reg) { [INFO] [stderr] 56 | | if !tvd.no_use_set.contains(®) { [INFO] [stderr] 57 | | result = reg; [INFO] [stderr] 58 | | break; [INFO] [stderr] 59 | | } [INFO] [stderr] 60 | | } [INFO] [stderr] | |_____________________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 55 | if !self.is_in_use(reg) && !tvd.no_use_set.contains(®) { [INFO] [stderr] 56 | result = reg; [INFO] [stderr] 57 | break; [INFO] [stderr] 58 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/debray_allocator.rs:82:21 [INFO] [stderr] | [INFO] [stderr] 82 | / if !self.is_in_use(reg) { [INFO] [stderr] 83 | | if !tvd.no_use_set.contains(®) { [INFO] [stderr] 84 | | if !tvd.conflict_set.contains(®) { [INFO] [stderr] 85 | | result = reg; [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#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 82 | if !self.is_in_use(reg) && !tvd.no_use_set.contains(®) { [INFO] [stderr] 83 | if !tvd.conflict_set.contains(®) { [INFO] [stderr] 84 | result = reg; [INFO] [stderr] 85 | break; [INFO] [stderr] 86 | } [INFO] [stderr] 87 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/debray_allocator.rs:83:25 [INFO] [stderr] | [INFO] [stderr] 83 | / if !tvd.no_use_set.contains(®) { [INFO] [stderr] 84 | | if !tvd.conflict_set.contains(®) { [INFO] [stderr] 85 | | result = reg; [INFO] [stderr] 86 | | break; [INFO] [stderr] 87 | | } [INFO] [stderr] 88 | | } [INFO] [stderr] | |_________________________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 83 | if !tvd.no_use_set.contains(®) && !tvd.conflict_set.contains(®) { [INFO] [stderr] 84 | result = reg; [INFO] [stderr] 85 | break; [INFO] [stderr] 86 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: this if statement can be collapsed [INFO] [stderr] --> src/prolog/fixtures.rs:55:29 [INFO] [stderr] | [INFO] [stderr] 55 | / if cn_u == cn_t && *u != ***t { [INFO] [stderr] 56 | | if !t_data.uses_reg(reg) { [INFO] [stderr] 57 | | t_data.no_use_set.insert(reg); [INFO] [stderr] 58 | | } [INFO] [stderr] 59 | | } [INFO] [stderr] | |_____________________________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if [INFO] [stderr] help: try [INFO] [stderr] | [INFO] [stderr] 55 | if cn_u == cn_t && *u != ***t && !t_data.uses_reg(reg) { [INFO] [stderr] 56 | t_data.no_use_set.insert(reg); [INFO] [stderr] 57 | } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/heap_print.rs:180:9 [INFO] [stderr] | [INFO] [stderr] 180 | / return match iter.next() { [INFO] [stderr] 181 | | None => true, [INFO] [stderr] 182 | | Some('*') => false, // if we start with comment token, we must quote. [INFO] [stderr] 183 | | Some(c) => if graphic_token_char!(c) { [INFO] [stderr] ... | [INFO] [stderr] 187 | | } [INFO] [stderr] 188 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] help: remove `return` as shown [INFO] [stderr] | [INFO] [stderr] 180 | match iter.next() { [INFO] [stderr] 181 | None => true, [INFO] [stderr] 182 | Some('*') => false, // if we start with comment token, we must quote. [INFO] [stderr] 183 | Some(c) => if graphic_token_char!(c) { [INFO] [stderr] 184 | iter.all(|c| graphic_token_char!(c)) [INFO] [stderr] 185 | } else { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/heap_print.rs:190:9 [INFO] [stderr] | [INFO] [stderr] 190 | / return match iter.next() { [INFO] [stderr] 191 | | None => false, [INFO] [stderr] 192 | | Some(c) => if graphic_token_char!(c) { [INFO] [stderr] 193 | | iter.all(|c| graphic_token_char!(c)) [INFO] [stderr] ... | [INFO] [stderr] 196 | | } [INFO] [stderr] 197 | | } [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] help: remove `return` as shown [INFO] [stderr] | [INFO] [stderr] 190 | match iter.next() { [INFO] [stderr] 191 | None => false, [INFO] [stderr] 192 | Some(c) => if graphic_token_char!(c) { [INFO] [stderr] 193 | iter.all(|c| graphic_token_char!(c)) [INFO] [stderr] 194 | } else { [INFO] [stderr] 195 | false [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/heap_print.rs:344:21 [INFO] [stderr] | [INFO] [stderr] 344 | return iter.next(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: remove `return` as shown: `iter.next()` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_return [INFO] [stderr] [INFO] [stderr] warning: unneeded return statement [INFO] [stderr] --> src/prolog/heap_print.rs:351:21 [INFO] [stderr] | [INFO] [stderr] 351 | return None; [INFO] [stderr] | ^^^^^^^^^^^^ help: remove `return` as shown: `None` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:28:9 [INFO] [stderr] | [INFO] [stderr] 28 | / match self { [INFO] [stderr] 29 | | &InlinedClauseType::CompareNumber(qt, ..) => qt.name(), [INFO] [stderr] 30 | | &InlinedClauseType::IsAtom(..) => "atom", [INFO] [stderr] 31 | | &InlinedClauseType::IsAtomic(..) => "atomic", [INFO] [stderr] ... | [INFO] [stderr] 39 | | &InlinedClauseType::IsVar(..) => "var", [INFO] [stderr] 40 | | } [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] 28 | match *self { [INFO] [stderr] 29 | InlinedClauseType::CompareNumber(qt, ..) => qt.name(), [INFO] [stderr] 30 | InlinedClauseType::IsAtom(..) => "atom", [INFO] [stderr] 31 | InlinedClauseType::IsAtomic(..) => "atomic", [INFO] [stderr] 32 | InlinedClauseType::IsCompound(..) => "compound", [INFO] [stderr] 33 | InlinedClauseType::IsInteger (..) => "integer", [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:139:9 [INFO] [stderr] | [INFO] [stderr] 139 | / match self { [INFO] [stderr] 140 | | &mut QueryTerm::Clause(_, _, _, ref mut use_default_cp) => *use_default_cp = true, [INFO] [stderr] 141 | | _ => {} [INFO] [stderr] 142 | | }; [INFO] [stderr] | |_________^ help: try this: `if let &mut QueryTerm::Clause(_, _, _, ref mut use_default_cp) = self { *use_default_cp = true }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:139:9 [INFO] [stderr] | [INFO] [stderr] 139 | / match self { [INFO] [stderr] 140 | | &mut QueryTerm::Clause(_, _, _, ref mut use_default_cp) => *use_default_cp = true, [INFO] [stderr] 141 | | _ => {} [INFO] [stderr] 142 | | }; [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] 139 | match *self { [INFO] [stderr] 140 | QueryTerm::Clause(_, _, _, ref mut use_default_cp) => *use_default_cp = true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:146:9 [INFO] [stderr] | [INFO] [stderr] 146 | / match self { [INFO] [stderr] 147 | | &QueryTerm::Clause(_, _, ref subterms, ..) => subterms.len(), [INFO] [stderr] 148 | | &QueryTerm::BlockedCut | &QueryTerm::UnblockedCut(..) => 0, [INFO] [stderr] 149 | | &QueryTerm::Jump(ref vars) => vars.len(), [INFO] [stderr] 150 | | &QueryTerm::GetLevelAndUnify(..) => 1, [INFO] [stderr] 151 | | } [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] 146 | match *self { [INFO] [stderr] 147 | QueryTerm::Clause(_, _, ref subterms, ..) => subterms.len(), [INFO] [stderr] 148 | QueryTerm::BlockedCut | QueryTerm::UnblockedCut(..) => 0, [INFO] [stderr] 149 | QueryTerm::Jump(ref vars) => vars.len(), [INFO] [stderr] 150 | QueryTerm::GetLevelAndUnify(..) => 1, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:175:9 [INFO] [stderr] | [INFO] [stderr] 175 | / match self { [INFO] [stderr] 176 | | &PredicateClause::Fact(ref term) => term.first_arg(), [INFO] [stderr] 177 | | &PredicateClause::Rule(ref rule) => rule.head.1.first().map(|bt| bt.as_ref()), [INFO] [stderr] 178 | | } [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] 175 | match *self { [INFO] [stderr] 176 | PredicateClause::Fact(ref term) => term.first_arg(), [INFO] [stderr] 177 | PredicateClause::Rule(ref rule) => rule.head.1.first().map(|bt| bt.as_ref()), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:182:9 [INFO] [stderr] | [INFO] [stderr] 182 | / match self { [INFO] [stderr] 183 | | &PredicateClause::Fact(ref term) => term.arity(), [INFO] [stderr] 184 | | &PredicateClause::Rule(ref rule) => rule.head.1.len() [INFO] [stderr] 185 | | } [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] 182 | match *self { [INFO] [stderr] 183 | PredicateClause::Fact(ref term) => term.arity(), [INFO] [stderr] 184 | PredicateClause::Rule(ref rule) => rule.head.1.len() [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:189:9 [INFO] [stderr] | [INFO] [stderr] 189 | / match self { [INFO] [stderr] 190 | | &PredicateClause::Fact(ref term) => term.name(), [INFO] [stderr] 191 | | &PredicateClause::Rule(ref rule) => Some(rule.head.0.clone()), [INFO] [stderr] 192 | | } [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] 189 | match *self { [INFO] [stderr] 190 | PredicateClause::Fact(ref term) => term.name(), [INFO] [stderr] 191 | PredicateClause::Rule(ref rule) => Some(rule.head.0.clone()), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:257:9 [INFO] [stderr] | [INFO] [stderr] 257 | / match self { [INFO] [stderr] 258 | | &SystemClauseType::CheckCutPoint => clause_name!("$check_cp"), [INFO] [stderr] 259 | | &SystemClauseType::ExpandTerm => clause_name!("$expand_term"), [INFO] [stderr] 260 | | &SystemClauseType::ExpandGoal => clause_name!("$expand_goal"), [INFO] [stderr] ... | [INFO] [stderr] 289 | | &SystemClauseType::WriteTerm => clause_name!("$write_term"), [INFO] [stderr] 290 | | } [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] 257 | match *self { [INFO] [stderr] 258 | SystemClauseType::CheckCutPoint => clause_name!("$check_cp"), [INFO] [stderr] 259 | SystemClauseType::ExpandTerm => clause_name!("$expand_term"), [INFO] [stderr] 260 | SystemClauseType::ExpandGoal => clause_name!("$expand_goal"), [INFO] [stderr] 261 | SystemClauseType::GetBValue => clause_name!("$get_b_value"), [INFO] [stderr] 262 | SystemClauseType::GetDoubleQuotes => clause_name!("$get_double_quotes"), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:386:9 [INFO] [stderr] | [INFO] [stderr] 386 | / match self { [INFO] [stderr] 387 | | &BuiltInClauseType::Compare | &BuiltInClauseType::CompareTerm(_) [INFO] [stderr] 388 | | | &BuiltInClauseType::NotEq | &BuiltInClauseType::Is(..) | &BuiltInClauseType::Eq [INFO] [stderr] 389 | | => Some(Fixity::In), [INFO] [stderr] 390 | | _ => None [INFO] [stderr] 391 | | } [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] 386 | match *self { [INFO] [stderr] 387 | BuiltInClauseType::Compare | BuiltInClauseType::CompareTerm(_) [INFO] [stderr] 388 | | BuiltInClauseType::NotEq | BuiltInClauseType::Is(..) | BuiltInClauseType::Eq [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:395:9 [INFO] [stderr] | [INFO] [stderr] 395 | / match self { [INFO] [stderr] 396 | | &BuiltInClauseType::AcyclicTerm => clause_name!("acyclic_term"), [INFO] [stderr] 397 | | &BuiltInClauseType::Arg => clause_name!("arg"), [INFO] [stderr] 398 | | &BuiltInClauseType::Compare => clause_name!("compare"), [INFO] [stderr] ... | [INFO] [stderr] 410 | | &BuiltInClauseType::PartialString => clause_name!("partial_string") [INFO] [stderr] 411 | | } [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] 395 | match *self { [INFO] [stderr] 396 | BuiltInClauseType::AcyclicTerm => clause_name!("acyclic_term"), [INFO] [stderr] 397 | BuiltInClauseType::Arg => clause_name!("arg"), [INFO] [stderr] 398 | BuiltInClauseType::Compare => clause_name!("compare"), [INFO] [stderr] 399 | BuiltInClauseType::CompareTerm(qt) => clause_name!(qt.name()), [INFO] [stderr] 400 | BuiltInClauseType::CyclicTerm => clause_name!("cyclic_term"), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:415:9 [INFO] [stderr] | [INFO] [stderr] 415 | / match self { [INFO] [stderr] 416 | | &BuiltInClauseType::AcyclicTerm => 1, [INFO] [stderr] 417 | | &BuiltInClauseType::Arg => 3, [INFO] [stderr] 418 | | &BuiltInClauseType::Compare => 2, [INFO] [stderr] ... | [INFO] [stderr] 430 | | &BuiltInClauseType::PartialString => 1, [INFO] [stderr] 431 | | } [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] 415 | match *self { [INFO] [stderr] 416 | BuiltInClauseType::AcyclicTerm => 1, [INFO] [stderr] 417 | BuiltInClauseType::Arg => 3, [INFO] [stderr] 418 | BuiltInClauseType::Compare => 2, [INFO] [stderr] 419 | BuiltInClauseType::CompareTerm(_) => 2, [INFO] [stderr] 420 | BuiltInClauseType::CyclicTerm => 1, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:463:9 [INFO] [stderr] | [INFO] [stderr] 463 | / match self { [INFO] [stderr] 464 | | &ClauseType::BuiltIn(ref built_in) => built_in.fixity(), [INFO] [stderr] 465 | | &ClauseType::Inlined(InlinedClauseType::CompareNumber(..)) => Some(Fixity::In), [INFO] [stderr] 466 | | &ClauseType::Op(_, fixity, _) => Some(fixity), [INFO] [stderr] 467 | | &ClauseType::System(ref system) => system.fixity(), [INFO] [stderr] 468 | | _ => None [INFO] [stderr] 469 | | } [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] 463 | match *self { [INFO] [stderr] 464 | ClauseType::BuiltIn(ref built_in) => built_in.fixity(), [INFO] [stderr] 465 | ClauseType::Inlined(InlinedClauseType::CompareNumber(..)) => Some(Fixity::In), [INFO] [stderr] 466 | ClauseType::Op(_, fixity, _) => Some(fixity), [INFO] [stderr] 467 | ClauseType::System(ref system) => system.fixity(), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:473:9 [INFO] [stderr] | [INFO] [stderr] 473 | / match self { [INFO] [stderr] 474 | | &ClauseType::CallN => clause_name!("call"), [INFO] [stderr] 475 | | &ClauseType::BuiltIn(ref built_in) => built_in.name(), [INFO] [stderr] 476 | | &ClauseType::Hook(ref hook) => hook.name(), [INFO] [stderr] ... | [INFO] [stderr] 480 | | &ClauseType::System(ref system) => system.name(), [INFO] [stderr] 481 | | } [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] 473 | match *self { [INFO] [stderr] 474 | ClauseType::CallN => clause_name!("call"), [INFO] [stderr] 475 | ClauseType::BuiltIn(ref built_in) => built_in.name(), [INFO] [stderr] 476 | ClauseType::Hook(ref hook) => hook.name(), [INFO] [stderr] 477 | ClauseType::Inlined(ref inlined) => clause_name!(inlined.name()), [INFO] [stderr] 478 | ClauseType::Op(ref name, ..) => name.clone(), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:542:9 [INFO] [stderr] | [INFO] [stderr] 542 | / match self { [INFO] [stderr] 543 | | &IndexedChoiceInstruction::Retry(offset) => offset, [INFO] [stderr] 544 | | &IndexedChoiceInstruction::Trust(offset) => offset, [INFO] [stderr] 545 | | &IndexedChoiceInstruction::Try(offset) => offset [INFO] [stderr] 546 | | } [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] 542 | match *self { [INFO] [stderr] 543 | IndexedChoiceInstruction::Retry(offset) => offset, [INFO] [stderr] 544 | IndexedChoiceInstruction::Trust(offset) => offset, [INFO] [stderr] 545 | IndexedChoiceInstruction::Try(offset) => offset [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:558:9 [INFO] [stderr] | [INFO] [stderr] 558 | / if let &ArithmeticTerm::Interm(interm) = self { [INFO] [stderr] 559 | | interm [INFO] [stderr] 560 | | } else { [INFO] [stderr] 561 | | interm [INFO] [stderr] 562 | | } [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] 558 | if let ArithmeticTerm::Interm(interm) = *self { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:598:9 [INFO] [stderr] | [INFO] [stderr] 598 | / match self { [INFO] [stderr] 599 | | &ControlInstruction::CallClause(..) => true, [INFO] [stderr] 600 | | &ControlInstruction::JmpBy(..) => true, [INFO] [stderr] 601 | | _ => false [INFO] [stderr] 602 | | } [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] 598 | match *self { [INFO] [stderr] 599 | ControlInstruction::CallClause(..) => true, [INFO] [stderr] 600 | ControlInstruction::JmpBy(..) => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:680:9 [INFO] [stderr] | [INFO] [stderr] 680 | / match self { [INFO] [stderr] 681 | | &Addr::Con(ref c) => write!(f, "Addr::Con({})", c), [INFO] [stderr] 682 | | &Addr::Lis(l) => write!(f, "Addr::Lis({})", l), [INFO] [stderr] 683 | | &Addr::HeapCell(h) => write!(f, "Addr::HeapCell({})", h), [INFO] [stderr] 684 | | &Addr::StackCell(fr, sc)=> write!(f, "Addr::StackCell({}, {})", fr, sc), [INFO] [stderr] 685 | | &Addr::Str(s) => write!(f, "Addr::Str({})", s) [INFO] [stderr] 686 | | } [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] 680 | match *self { [INFO] [stderr] 681 | Addr::Con(ref c) => write!(f, "Addr::Con({})", c), [INFO] [stderr] 682 | Addr::Lis(l) => write!(f, "Addr::Lis({})", l), [INFO] [stderr] 683 | Addr::HeapCell(h) => write!(f, "Addr::HeapCell({})", h), [INFO] [stderr] 684 | Addr::StackCell(fr, sc)=> write!(f, "Addr::StackCell({}, {})", fr, sc), [INFO] [stderr] 685 | Addr::Str(s) => write!(f, "Addr::Str({})", s) [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:699:9 [INFO] [stderr] | [INFO] [stderr] 699 | / match self { [INFO] [stderr] 700 | | &Addr::StackCell(fr, sc) => [INFO] [stderr] 701 | | match *r { [INFO] [stderr] 702 | | Ref::HeapCell(_) => Some(Ordering::Greater), [INFO] [stderr] ... | [INFO] [stderr] 717 | | _ => None [INFO] [stderr] 718 | | } [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] 699 | match *self { [INFO] [stderr] 700 | Addr::StackCell(fr, sc) => [INFO] [stderr] 701 | match *r { [INFO] [stderr] 702 | Ref::HeapCell(_) => Some(Ordering::Greater), [INFO] [stderr] 703 | Ref::StackCell(fr1, sc1) => [INFO] [stderr] 704 | if fr1 < fr || (fr1 == fr && sc1 < sc) { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:713:17 [INFO] [stderr] | [INFO] [stderr] 713 | / match r { [INFO] [stderr] 714 | | &Ref::StackCell(..) => Some(Ordering::Less), [INFO] [stderr] 715 | | &Ref::HeapCell(h1) => h.partial_cmp(&h1) [INFO] [stderr] 716 | | }, [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] 713 | match *r { [INFO] [stderr] 714 | Ref::StackCell(..) => Some(Ordering::Less), [INFO] [stderr] 715 | Ref::HeapCell(h1) => h.partial_cmp(&h1) [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:724:9 [INFO] [stderr] | [INFO] [stderr] 724 | / match self { [INFO] [stderr] 725 | | &Addr::HeapCell(_) | &Addr::StackCell(_, _) => true, [INFO] [stderr] 726 | | _ => false [INFO] [stderr] 727 | | } [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] 724 | match *self { [INFO] [stderr] 725 | Addr::HeapCell(_) | Addr::StackCell(_, _) => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:731:9 [INFO] [stderr] | [INFO] [stderr] 731 | / match self { [INFO] [stderr] 732 | | &Addr::HeapCell(hc) => Some(Ref::HeapCell(hc)), [INFO] [stderr] 733 | | &Addr::StackCell(fr, sc) => Some(Ref::StackCell(fr, sc)), [INFO] [stderr] 734 | | _ => None [INFO] [stderr] 735 | | } [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] 731 | match *self { [INFO] [stderr] 732 | Addr::HeapCell(hc) => Some(Ref::HeapCell(hc)), [INFO] [stderr] 733 | Addr::StackCell(fr, sc) => Some(Ref::StackCell(fr, sc)), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:739:9 [INFO] [stderr] | [INFO] [stderr] 739 | / match self { [INFO] [stderr] 740 | | &Addr::StackCell(addr, _) if addr >= e => false, [INFO] [stderr] 741 | | _ => true [INFO] [stderr] 742 | | } [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] 739 | match *self { [INFO] [stderr] 740 | Addr::StackCell(addr, _) if addr >= e => false, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:804:9 [INFO] [stderr] | [INFO] [stderr] 804 | / match self { [INFO] [stderr] 805 | | &HeapCellValue::Addr(ref a) => a.clone(), [INFO] [stderr] 806 | | &HeapCellValue::NamedStr(_, _, _) => Addr::Str(focus) [INFO] [stderr] 807 | | } [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] 804 | match *self { [INFO] [stderr] 805 | HeapCellValue::Addr(ref a) => a.clone(), [INFO] [stderr] 806 | HeapCellValue::NamedStr(_, _, _) => Addr::Str(focus) [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:827:9 [INFO] [stderr] | [INFO] [stderr] 827 | / if let &IndexPtr::Undefined = index_ptr { [INFO] [stderr] 828 | | true [INFO] [stderr] 829 | | } else { [INFO] [stderr] 830 | | false [INFO] [stderr] 831 | | } [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] 827 | if let IndexPtr::Undefined = *index_ptr { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:879:9 [INFO] [stderr] | [INFO] [stderr] 879 | / match self { [INFO] [stderr] 880 | | &CodePtr::BuiltInClause(_, ref local) [INFO] [stderr] 881 | | | &CodePtr::CallN(_, ref local) [INFO] [stderr] 882 | | | &CodePtr::Local(ref local) => local.clone() [INFO] [stderr] 883 | | } [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] 879 | match *self { [INFO] [stderr] 880 | CodePtr::BuiltInClause(_, ref local) [INFO] [stderr] 881 | | CodePtr::CallN(_, ref local) [INFO] [stderr] 882 | | CodePtr::Local(ref local) => local.clone() [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/instructions.rs:882:43 [INFO] [stderr] | [INFO] [stderr] 882 | | &CodePtr::Local(ref local) => local.clone() [INFO] [stderr] | ^^^^^^^^^^^^^ help: try dereferencing it: `*local` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::clone_on_copy)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:898:9 [INFO] [stderr] | [INFO] [stderr] 898 | / match cp { [INFO] [stderr] 899 | | CodePtr::Local(local) => *self = local, [INFO] [stderr] 900 | | _ => {} [INFO] [stderr] 901 | | } [INFO] [stderr] | |_________^ help: try this: `if let CodePtr::Local(local) = cp { *self = local }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:958:9 [INFO] [stderr] | [INFO] [stderr] 958 | / match self { [INFO] [stderr] 959 | | &mut LocalCodePtr::InSituDirEntry(ref mut p) [INFO] [stderr] 960 | | | &mut LocalCodePtr::UserGoalExpansion(ref mut p) [INFO] [stderr] 961 | | | &mut LocalCodePtr::UserTermExpansion(ref mut p) [INFO] [stderr] 962 | | | &mut LocalCodePtr::DirEntry(ref mut p) [INFO] [stderr] 963 | | | &mut LocalCodePtr::TopLevel(_, ref mut p) => *p += rhs [INFO] [stderr] 964 | | } [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] 958 | match *self { [INFO] [stderr] 959 | LocalCodePtr::InSituDirEntry(ref mut p) [INFO] [stderr] 960 | | LocalCodePtr::UserGoalExpansion(ref mut p) [INFO] [stderr] 961 | | LocalCodePtr::UserTermExpansion(ref mut p) [INFO] [stderr] 962 | | LocalCodePtr::DirEntry(ref mut p) [INFO] [stderr] 963 | | LocalCodePtr::TopLevel(_, ref mut p) => *p += rhs [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:981:9 [INFO] [stderr] | [INFO] [stderr] 981 | / match self { [INFO] [stderr] 982 | | &mut CodePtr::Local(ref mut local) => *local += rhs, [INFO] [stderr] 983 | | _ => *self = CodePtr::Local(self.local() + rhs) [INFO] [stderr] 984 | | } [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] 981 | match *self { [INFO] [stderr] 982 | CodePtr::Local(ref mut local) => *local += rhs, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1052:9 [INFO] [stderr] | [INFO] [stderr] 1052 | / match term { [INFO] [stderr] 1053 | | &Term::AnonVar => [INFO] [stderr] 1054 | | TermIterState::AnonVar(lvl), [INFO] [stderr] 1055 | | &Term::Clause(ref cell, ref name, ref subterms, fixity) => { [INFO] [stderr] ... | [INFO] [stderr] 1069 | | TermIterState::Var(lvl, cell, var.clone()) [INFO] [stderr] 1070 | | } [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] 1052 | match *term { [INFO] [stderr] 1053 | Term::AnonVar => [INFO] [stderr] 1054 | TermIterState::AnonVar(lvl), [INFO] [stderr] 1055 | Term::Clause(ref cell, ref name, ref subterms, fixity) => { [INFO] [stderr] 1056 | let ct = if let Some(fixity) = fixity { [INFO] [stderr] 1057 | ClauseType::Op(name.clone(), fixity, CodeIndex::default()) [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:1103:13 [INFO] [stderr] | [INFO] [stderr] 1103 | / match self.get_code_index((name.clone(), arity), mod_name.clone()) { [INFO] [stderr] 1104 | | Some(CodeIndex (ref code_idx)) => { [INFO] [stderr] 1105 | | if &code_idx.borrow().1 != &module.module_decl.name { [INFO] [stderr] 1106 | | continue; [INFO] [stderr] ... | [INFO] [stderr] 1135 | | _ => {} [INFO] [stderr] 1136 | | }; [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 1103 | if let Some(CodeIndex (ref code_idx)) = self.get_code_index((name.clone(), arity), mod_name.clone()) { [INFO] [stderr] 1104 | if &code_idx.borrow().1 != &module.module_decl.name { [INFO] [stderr] 1105 | continue; [INFO] [stderr] 1106 | } [INFO] [stderr] 1107 | [INFO] [stderr] 1108 | self.remove_code_index((name.clone(), arity)); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: needlessly taken reference of both operands [INFO] [stderr] --> src/prolog/instructions.rs:1105:24 [INFO] [stderr] | [INFO] [stderr] 1105 | if &code_idx.borrow().1 != &module.module_decl.name { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::op_ref)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#op_ref [INFO] [stderr] help: use the values directly [INFO] [stderr] | [INFO] [stderr] 1105 | if code_idx.borrow().1 != module.module_decl.name { [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/prolog/instructions.rs:1174:69 [INFO] [stderr] | [INFO] [stderr] 1174 | fn use_qualified_module(&mut self, submodule: &Module, exports: &Vec) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateKey]` [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: large size difference between variants [INFO] [stderr] --> src/prolog/instructions.rs:1225:5 [INFO] [stderr] | [INFO] [stderr] 1225 | Hook(CompileTimeHook, PredicateClause, VecDeque), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::large_enum_variant)] on by default [INFO] [stderr] help: consider boxing the large fields to reduce the total size of the enum [INFO] [stderr] --> src/prolog/instructions.rs:1225:5 [INFO] [stderr] | [INFO] [stderr] 1225 | Hook(CompileTimeHook, PredicateClause, VecDeque), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1236:9 [INFO] [stderr] | [INFO] [stderr] 1236 | if let &Declaration::Module(_) = self { true } else { false } [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] 1236 | if let Declaration::Module(_) = *self { true } else { false } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ [INFO] [stderr] [INFO] [stderr] warning: large size difference between variants [INFO] [stderr] --> src/prolog/instructions.rs:1241:5 [INFO] [stderr] | [INFO] [stderr] 1241 | Declaration(Declaration), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [INFO] [stderr] help: consider boxing the large fields to reduce the total size of the enum [INFO] [stderr] | [INFO] [stderr] 1241 | Declaration(Box), [INFO] [stderr] | ^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1250:9 [INFO] [stderr] | [INFO] [stderr] 1250 | / match self { [INFO] [stderr] 1251 | | &TopLevel::Declaration(_) => None, [INFO] [stderr] 1252 | | &TopLevel::Fact(ref term) => term.name(), [INFO] [stderr] 1253 | | &TopLevel::Predicate(ref clauses) => [INFO] [stderr] ... | [INFO] [stderr] 1257 | | Some(head.0.clone()) [INFO] [stderr] 1258 | | } [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] 1250 | match *self { [INFO] [stderr] 1251 | TopLevel::Declaration(_) => None, [INFO] [stderr] 1252 | TopLevel::Fact(ref term) => term.name(), [INFO] [stderr] 1253 | TopLevel::Predicate(ref clauses) => [INFO] [stderr] 1254 | clauses.0.first().and_then(|ref term| term.name()), [INFO] [stderr] 1255 | TopLevel::Query(_) => None, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1262:9 [INFO] [stderr] | [INFO] [stderr] 1262 | / match self { [INFO] [stderr] 1263 | | &TopLevel::Declaration(_) => 0, [INFO] [stderr] 1264 | | &TopLevel::Fact(ref term) => term.arity(), [INFO] [stderr] 1265 | | &TopLevel::Predicate(ref clauses) => [INFO] [stderr] ... | [INFO] [stderr] 1268 | | &TopLevel::Rule(Rule { ref head, .. }) => head.1.len() [INFO] [stderr] 1269 | | } [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] 1262 | match *self { [INFO] [stderr] 1263 | TopLevel::Declaration(_) => 0, [INFO] [stderr] 1264 | TopLevel::Fact(ref term) => term.arity(), [INFO] [stderr] 1265 | TopLevel::Predicate(ref clauses) => [INFO] [stderr] 1266 | clauses.0.first().map(|t| t.arity()).unwrap_or(0), [INFO] [stderr] 1267 | TopLevel::Query(_) => 0, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1302:9 [INFO] [stderr] | [INFO] [stderr] 1302 | / match self { [INFO] [stderr] 1303 | | &VarData::Temp(_, r, _) => RegType::Temp(r), [INFO] [stderr] 1304 | | &VarData::Perm(r) => RegType::Perm(r) [INFO] [stderr] 1305 | | } [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] 1302 | match *self { [INFO] [stderr] 1303 | VarData::Temp(_, r, _) => RegType::Temp(r), [INFO] [stderr] 1304 | VarData::Perm(r) => RegType::Perm(r) [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:1399:13 [INFO] [stderr] | [INFO] [stderr] 1399 | / match op_dir.get(&(name.clone(), Fixity::Post)) { [INFO] [stderr] 1400 | | Some(_) => return Err(SessionError::OpIsInfixAndPostFix), [INFO] [stderr] 1401 | | _ => {} [INFO] [stderr] 1402 | | }; [INFO] [stderr] | |_____________^ help: try this: `if let Some(_) = op_dir.get(&(name.clone(), Fixity::Post)) { return Err(SessionError::OpIsInfixAndPostFix) }` [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: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:1406:13 [INFO] [stderr] | [INFO] [stderr] 1406 | / match op_dir.get(&(name.clone(), Fixity::In)) { [INFO] [stderr] 1407 | | Some(_) => return Err(SessionError::OpIsInfixAndPostFix), [INFO] [stderr] 1408 | | _ => {} [INFO] [stderr] 1409 | | }; [INFO] [stderr] | |_____________^ help: try this: `if let Some(_) = op_dir.get(&(name.clone(), Fixity::In)) { return Err(SessionError::OpIsInfixAndPostFix) }` [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: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/and_stack.rs:20:20 [INFO] [stderr] | [INFO] [stderr] 20 | perms: (1 .. n+1).map(|i| Addr::StackCell(fr, i)).collect() [INFO] [stderr] | ^^^^^^^^^^ help: use: `(1..=n)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::range_plus_one)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: this function has too many arguments (8/7) [INFO] [stderr] --> src/prolog/allocator.rs:18:5 [INFO] [stderr] | [INFO] [stderr] 18 | / fn mark_reserved_var(&mut self, Rc, Level, &'a Cell, GenContext, [INFO] [stderr] 19 | | &mut Vec, RegType, bool) [INFO] [stderr] 20 | | where Target: CompilationTarget<'a>; [INFO] [stderr] | |____________________________________________^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::too_many_arguments)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [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/prolog/allocator.rs:27:33 [INFO] [stderr] | [INFO] [stderr] 27 | fn reset_at_head(&mut self, &Vec>); [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/allocator.rs:64:9 [INFO] [stderr] | [INFO] [stderr] 64 | / match self.bindings_mut().get_mut(&var).unwrap() { [INFO] [stderr] 65 | | &mut VarData::Temp(_, ref mut s, _) => *s = r.reg_num(), [INFO] [stderr] 66 | | &mut VarData::Perm(ref mut s) => *s = r.reg_num() [INFO] [stderr] 67 | | } [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] 64 | match *self.bindings_mut().get_mut(&var).unwrap() { [INFO] [stderr] 65 | VarData::Temp(_, ref mut s, _) => *s = r.reg_num(), [INFO] [stderr] 66 | VarData::Perm(ref mut s) => *s = r.reg_num() [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/toplevel.rs:41:17 [INFO] [stderr] | [INFO] [stderr] 41 | / match &self.static_code_dir { [INFO] [stderr] 42 | | &Some(ref code_dir) => code_dir.get(&(name.clone(), arity)), [INFO] [stderr] 43 | | _ => None [INFO] [stderr] 44 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 41 | match self.static_code_dir { [INFO] [stderr] 42 | Some(ref code_dir) => code_dir.get(&(name.clone(), arity)), [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/prolog/toplevel.rs:83:51 [INFO] [stderr] | [INFO] [stderr] 83 | fn is_compile_time_hook(name: &ClauseName, terms: &Vec>) -> Option { [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/toplevel.rs:86:13 [INFO] [stderr] | [INFO] [stderr] 86 | / if let &Term::Clause(_, ref name, ref terms, None) = term.as_ref() { [INFO] [stderr] 87 | | return get_compile_time_hook(name.as_str(), terms.len()); [INFO] [stderr] 88 | | } [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] 86 | if let Term::Clause(_, ref name, ref terms, None) = *term.as_ref() { [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/prolog/toplevel.rs:246:42 [INFO] [stderr] | [INFO] [stderr] 246 | fn is_consistent(tl: &TopLevel, clauses: &Vec) -> bool [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateClause]` [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/prolog/toplevel.rs:308:9 [INFO] [stderr] | [INFO] [stderr] 308 | / match term { [INFO] [stderr] 309 | | &mut Term::Constant(_, Constant::Atom(ref mut var, _)) if var.as_str() == "!" => [INFO] [stderr] 310 | | *var = name.clone(), [INFO] [stderr] 311 | | _ => {} [INFO] [stderr] 312 | | } [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] 308 | match *term { [INFO] [stderr] 309 | Term::Constant(_, Constant::Atom(ref mut var, _)) if var.as_str() == "!" => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/toplevel.rs:317:25 [INFO] [stderr] | [INFO] [stderr] 317 | let cut_var_found = match term { [INFO] [stderr] | _________________________^ [INFO] [stderr] 318 | | &mut Term::Constant(_, Constant::Atom(ref var, _)) if var.as_str() == "!" => true, [INFO] [stderr] 319 | | _ => false [INFO] [stderr] 320 | | }; [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] 317 | let cut_var_found = match *term { [INFO] [stderr] 318 | Term::Constant(_, Constant::Atom(ref var, _)) if var.as_str() == "!" => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: large size difference between variants [INFO] [stderr] --> src/prolog/toplevel.rs:354:5 [INFO] [stderr] | [INFO] [stderr] 354 | Decl(TopLevel, VecDeque) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] help: consider boxing the large fields to reduce the total size of the enum [INFO] [stderr] --> src/prolog/toplevel.rs:354:5 [INFO] [stderr] | [INFO] [stderr] 354 | Decl(TopLevel, VecDeque) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [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/prolog/toplevel.rs:382:41 [INFO] [stderr] | [INFO] [stderr] 382 | fn fabricate_rule_body(&self, vars: &Vec, body_term: Term) -> Term [INFO] [stderr] | ^^^^^^^^^^ help: change this to: `&[Term]` [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: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name [INFO] [stderr] --> src/prolog/toplevel.rs:455:22 [INFO] [stderr] | [INFO] [stderr] 455 | fn to_query_term(&mut self, indices: &mut CompositeIndices, term: Term) -> Result [INFO] [stderr] | ^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::wrong_self_convention)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/toplevel.rs:571:17 [INFO] [stderr] | [INFO] [stderr] 571 | / if let &mut Term::Clause(_, ref name, ref mut subterms, _) = &mut term { [INFO] [stderr] 572 | | if name.as_str() == "->" && subterms.len() == 2 { [INFO] [stderr] 573 | | let conq = *subterms.pop().unwrap(); [INFO] [stderr] 574 | | let prec = *subterms.pop().unwrap(); [INFO] [stderr] ... | [INFO] [stderr] 578 | | } [INFO] [stderr] 579 | | } [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] 571 | if let Term::Clause(_, ref name, ref mut subterms, _) = *(&mut term) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: The function/method `Some` doesn't need a mutable reference [INFO] [stderr] --> src/prolog/toplevel.rs:703:58 [INFO] [stderr] | [INFO] [stderr] 703 | let mut indices = composite_indices!(false, indices, &mut code_dir); [INFO] [stderr] | ^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unnecessary_mut_passed)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed [INFO] [stderr] [INFO] [stderr] warning: The function/method `Some` doesn't need a mutable reference [INFO] [stderr] --> src/prolog/toplevel.rs:745:36 [INFO] [stderr] | [INFO] [stderr] 745 | &mut self.term_stream.indices.code_dir); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed [INFO] [stderr] [INFO] [stderr] warning: The function/method `Some` doesn't need a mutable reference [INFO] [stderr] --> src/prolog/toplevel.rs:775:36 [INFO] [stderr] | [INFO] [stderr] 775 | &mut self.term_stream.indices.code_dir); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/machine_state.rs:248:30 [INFO] [stderr] | [INFO] [stderr] 248 | Some(ref idx) => if let &IndexPtr::Index(p) = &idx.0.borrow().0 { [INFO] [stderr] | ______________________________^ [INFO] [stderr] 249 | | Some(p) [INFO] [stderr] 250 | | } else { [INFO] [stderr] 251 | | None [INFO] [stderr] 252 | | }, [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: try [INFO] [stderr] | [INFO] [stderr] 248 | Some(ref idx) => if let IndexPtr::Index(p) = idx.0.borrow().0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: this argument is passed by reference, but would be more efficient if passed by value [INFO] [stderr] --> src/prolog/machine/machine_state.rs:660:69 [INFO] [stderr] | [INFO] [stderr] 660 | fn compile_hook(&mut self, machine_st: &mut MachineState, hook: &CompileTimeHook) -> CallResult [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: consider passing by value instead: `CompileTimeHook` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::trivially_copy_pass_by_ref)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state.rs:288:18 [INFO] [stderr] | [INFO] [stderr] 288 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state.rs:293:25 [INFO] [stderr] | [INFO] [stderr] 293 | machine_st.cp = machine_st.or_stack[b].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `machine_st.or_stack[b].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state.rs:326:18 [INFO] [stderr] | [INFO] [stderr] 326 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state.rs:331:25 [INFO] [stderr] | [INFO] [stderr] 331 | machine_st.cp = machine_st.or_stack[b].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `machine_st.or_stack[b].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state.rs:364:18 [INFO] [stderr] | [INFO] [stderr] 364 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state.rs:369:25 [INFO] [stderr] | [INFO] [stderr] 369 | machine_st.cp = machine_st.or_stack[b].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `machine_st.or_stack[b].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state.rs:403:18 [INFO] [stderr] | [INFO] [stderr] 403 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state.rs:408:25 [INFO] [stderr] | [INFO] [stderr] 408 | machine_st.cp = machine_st.or_stack[b].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `machine_st.or_stack[b].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state.rs:513:9 [INFO] [stderr] | [INFO] [stderr] 513 | / match ct { [INFO] [stderr] 514 | | &BuiltInClauseType::AcyclicTerm => { [INFO] [stderr] 515 | | let addr = machine_st[temp_v!(1)].clone(); [INFO] [stderr] 516 | | machine_st.fail = machine_st.is_cyclic_term(addr); [INFO] [stderr] ... | [INFO] [stderr] 656 | | }, [INFO] [stderr] 657 | | } [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] 513 | match *ct { [INFO] [stderr] 514 | BuiltInClauseType::AcyclicTerm => { [INFO] [stderr] 515 | let addr = machine_st[temp_v!(1)].clone(); [INFO] [stderr] 516 | machine_st.fail = machine_st.is_cyclic_term(addr); [INFO] [stderr] 517 | return_from_clause!(machine_st.last_call, machine_st) [INFO] [stderr] 518 | }, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state.rs:787:40 [INFO] [stderr] | [INFO] [stderr] 787 | pub(crate) fn new_in_place(policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::borrowed_box)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> src/prolog/machine/machine_state.rs:800:45 [INFO] [stderr] | [INFO] [stderr] 800 | if self.inference_limit_exceeded || machine_st.ball.stub.len() > 0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!machine_st.ball.stub.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: methods called `into_*` usually take self by value; consider choosing a less ambiguous name [INFO] [stderr] --> src/prolog/machine/machine_state.rs:845:30 [INFO] [stderr] | [INFO] [stderr] 845 | pub(crate) fn into_inner(&mut self) -> Box { [INFO] [stderr] | ^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:16:5 [INFO] [stderr] | [INFO] [stderr] 16 | / if let &mut Term::Clause(_, ref name, ref mut subterms, _) = term { [INFO] [stderr] 17 | | if name.as_str() == s && subterms.len() == 2 { [INFO] [stderr] 18 | | let snd = *subterms.pop().unwrap(); [INFO] [stderr] 19 | | let fst = *subterms.pop().unwrap(); [INFO] [stderr] ... | [INFO] [stderr] 22 | | } [INFO] [stderr] 23 | | } [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] 16 | if let Term::Clause(_, ref name, ref mut subterms, _) = *term { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ [INFO] [stderr] [INFO] [stderr] warning: local variable doesn't need to be boxed here [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:102:54 [INFO] [stderr] | [INFO] [stderr] 102 | fn extract_from_list(&mut self, head: Box, tail: Box) [INFO] [stderr] | ^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::boxed_local)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local [INFO] [stderr] [INFO] [stderr] warning: local variable doesn't need to be boxed here [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:102:37 [INFO] [stderr] | [INFO] [stderr] 102 | fn extract_from_list(&mut self, head: Box, tail: Box) [INFO] [stderr] | ^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:124:20 [INFO] [stderr] | [INFO] [stderr] 124 | Ok(self.stack.extend(iter)) [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] 124 | Ok(()) [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:127:20 [INFO] [stderr] | [INFO] [stderr] 127 | Ok(self.stack.push(term)), [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] 127 | Ok(()), [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] error: this `if` has identical blocks [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:175:73 [INFO] [stderr] | [INFO] [stderr] 175 | } else if name.as_str() == "?-" && terms.len() == 1 { [INFO] [stderr] | _________________________________________________________________________^ [INFO] [stderr] 176 | | let comma_term = *terms.pop().unwrap(); [INFO] [stderr] 177 | | unfold_by_str(comma_term, ",") [INFO] [stderr] 178 | | } else { [INFO] [stderr] | |_____________________^ [INFO] [stderr] | [INFO] [stderr] = note: #[deny(clippy::if_same_then_else)] on by default [INFO] [stderr] note: same as this [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:172:82 [INFO] [stderr] | [INFO] [stderr] 172 | let old_terms = if name.as_str() == ":-" && terms.len() == 2 { [INFO] [stderr] | __________________________________________________________________________________^ [INFO] [stderr] 173 | | let comma_term = *terms.pop().unwrap(); [INFO] [stderr] 174 | | unfold_by_str(comma_term, ",") [INFO] [stderr] 175 | | } else if name.as_str() == "?-" && terms.len() == 1 { [INFO] [stderr] | |_____________________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:224:25 [INFO] [stderr] | [INFO] [stderr] 224 | / if let &HeapCellValue::NamedStr(n2, ref f2, _) = &self.heap[a2] { [INFO] [stderr] 225 | | if f2.as_str() == "." && n2 == 2 { [INFO] [stderr] 226 | | pdl.push(Addr::HeapCell(a1)); [INFO] [stderr] 227 | | pdl.push(Addr::HeapCell(a2 + 1)); [INFO] [stderr] ... | [INFO] [stderr] 233 | | } [INFO] [stderr] 234 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 224 | if let HeapCellValue::NamedStr(n2, ref f2, _) = self.heap[a2] { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:309:25 [INFO] [stderr] | [INFO] [stderr] 309 | / if let &HeapCellValue::NamedStr(n1, ref f1, _) = r1 { [INFO] [stderr] 310 | | if let &HeapCellValue::NamedStr(n2, ref f2, _) = r2 { [INFO] [stderr] 311 | | if n1 == n2 && *f1 == *f2 { [INFO] [stderr] 312 | | for i in 1 .. n1 + 1 { [INFO] [stderr] ... | [INFO] [stderr] 319 | | } [INFO] [stderr] 320 | | } [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] 309 | if let HeapCellValue::NamedStr(n1, ref f1, _) = *r1 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:310:29 [INFO] [stderr] | [INFO] [stderr] 310 | / if let &HeapCellValue::NamedStr(n2, ref f2, _) = r2 { [INFO] [stderr] 311 | | if n1 == n2 && *f1 == *f2 { [INFO] [stderr] 312 | | for i in 1 .. n1 + 1 { [INFO] [stderr] 313 | | pdl.push(Addr::HeapCell(a1 + i)); [INFO] [stderr] ... | [INFO] [stderr] 318 | | } [INFO] [stderr] 319 | | } [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] 310 | if let HeapCellValue::NamedStr(n2, ref f2, _) = *r2 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:312:46 [INFO] [stderr] | [INFO] [stderr] 312 | for i in 1 .. n1 + 1 { [INFO] [stderr] | ^^^^^^^^^^^ help: use: `1..=n1` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:509:9 [INFO] [stderr] | [INFO] [stderr] 509 | / match at { [INFO] [stderr] 510 | | &ArithmeticTerm::Reg(r) => self.arith_eval_by_metacall(r), [INFO] [stderr] 511 | | &ArithmeticTerm::Interm(i) => Ok(self.interms[i-1].clone()), [INFO] [stderr] 512 | | &ArithmeticTerm::Number(ref n) => Ok(n.clone()), [INFO] [stderr] 513 | | } [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] 509 | match *at { [INFO] [stderr] 510 | ArithmeticTerm::Reg(r) => self.arith_eval_by_metacall(r), [INFO] [stderr] 511 | ArithmeticTerm::Interm(i) => Ok(self.interms[i-1].clone()), [INFO] [stderr] 512 | ArithmeticTerm::Number(ref n) => Ok(n.clone()), [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/prolog/machine/machine_state_impl.rs:516:57 [INFO] [stderr] | [INFO] [stderr] 516 | fn get_rational(&self, at: &ArithmeticTerm, caller: &MachineStub) [INFO] [stderr] | ^^^^^^^^^^^^ [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/prolog/machine/machine_state_impl.rs:826:9 [INFO] [stderr] | [INFO] [stderr] 826 | / match instr { [INFO] [stderr] 827 | | &ArithmeticInstruction::Add(ref a1, ref a2, t) => { [INFO] [stderr] 828 | | let n1 = try_or_fail!(self, self.get_number(a1)); [INFO] [stderr] 829 | | let n2 = try_or_fail!(self, self.get_number(a2)); [INFO] [stderr] ... | [INFO] [stderr] 945 | | } [INFO] [stderr] 946 | | }; [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] 826 | match *instr { [INFO] [stderr] 827 | ArithmeticInstruction::Add(ref a1, ref a2, t) => { [INFO] [stderr] 828 | let n1 = try_or_fail!(self, self.get_number(a1)); [INFO] [stderr] 829 | let n2 = try_or_fail!(self, self.get_number(a2)); [INFO] [stderr] 830 | [INFO] [stderr] 831 | self.interms[t - 1] = n1 + n2; [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:950:9 [INFO] [stderr] | [INFO] [stderr] 950 | / match instr { [INFO] [stderr] 951 | | &FactInstruction::GetConstant(_, ref c, reg) => { [INFO] [stderr] 952 | | let addr = self[reg].clone(); [INFO] [stderr] 953 | | self.write_constant_to_var(addr, c.clone()); [INFO] [stderr] ... | [INFO] [stderr] 1123 | | } [INFO] [stderr] 1124 | | }; [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] 950 | match *instr { [INFO] [stderr] 951 | FactInstruction::GetConstant(_, ref c, reg) => { [INFO] [stderr] 952 | let addr = self[reg].clone(); [INFO] [stderr] 953 | self.write_constant_to_var(addr, c.clone()); [INFO] [stderr] 954 | }, [INFO] [stderr] 955 | FactInstruction::GetList(_, reg) => { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1008:25 [INFO] [stderr] | [INFO] [stderr] 1008 | / if let &HeapCellValue::NamedStr(narity, ref s, _) = result { [INFO] [stderr] 1009 | | if narity == arity && ct.name() == *s { [INFO] [stderr] 1010 | | self.s = a + 1; [INFO] [stderr] 1011 | | self.mode = MachineMode::Read; [INFO] [stderr] ... | [INFO] [stderr] 1014 | | } [INFO] [stderr] 1015 | | } [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] 1008 | if let HeapCellValue::NamedStr(narity, ref s, _) = *result { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1128:9 [INFO] [stderr] | [INFO] [stderr] 1128 | / match instr { [INFO] [stderr] 1129 | | &IndexingInstruction::SwitchOnTerm(v, c, l, s) => { [INFO] [stderr] 1130 | | let a1 = self.registers[1].clone(); [INFO] [stderr] 1131 | | let addr = self.store(self.deref(a1)); [INFO] [stderr] ... | [INFO] [stderr] 1187 | | } [INFO] [stderr] 1188 | | }; [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] 1128 | match *instr { [INFO] [stderr] 1129 | IndexingInstruction::SwitchOnTerm(v, c, l, s) => { [INFO] [stderr] 1130 | let a1 = self.registers[1].clone(); [INFO] [stderr] 1131 | let addr = self.store(self.deref(a1)); [INFO] [stderr] 1132 | [INFO] [stderr] 1133 | let offset = match addr { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1171:25 [INFO] [stderr] | [INFO] [stderr] 1171 | / if let &HeapCellValue::NamedStr(arity, ref name, _) = &self.heap[s] { [INFO] [stderr] 1172 | | match hm.get(&(name.clone(), arity)) { [INFO] [stderr] 1173 | | Some(offset) => *offset, [INFO] [stderr] 1174 | | _ => 0 [INFO] [stderr] ... | [INFO] [stderr] 1177 | | 0 [INFO] [stderr] 1178 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 1171 | if let HeapCellValue::NamedStr(arity, ref name, _) = self.heap[s] { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1192:9 [INFO] [stderr] | [INFO] [stderr] 1192 | / match instr { [INFO] [stderr] 1193 | | &QueryInstruction::GetVariable(norm, arg) => [INFO] [stderr] 1194 | | self[norm] = self.registers[arg].clone(), [INFO] [stderr] 1195 | | &QueryInstruction::PutConstant(_, ref constant, reg) => [INFO] [stderr] ... | [INFO] [stderr] 1271 | | } [INFO] [stderr] 1272 | | } [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] 1192 | match *instr { [INFO] [stderr] 1193 | QueryInstruction::GetVariable(norm, arg) => [INFO] [stderr] 1194 | self[norm] = self.registers[arg].clone(), [INFO] [stderr] 1195 | QueryInstruction::PutConstant(_, ref constant, reg) => [INFO] [stderr] 1196 | self[reg] = Addr::Con(constant.clone()), [INFO] [stderr] 1197 | QueryInstruction::PutList(_, reg) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1322:30 [INFO] [stderr] | [INFO] [stderr] 1322 | for i in 1 .. narity + 1 { [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: use: `1..=narity` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1686:9 [INFO] [stderr] | [INFO] [stderr] 1686 | / match inlined { [INFO] [stderr] 1687 | | &InlinedClauseType::CompareNumber(cmp, ref at_1, ref at_2) => { [INFO] [stderr] 1688 | | let n1 = try_or_fail!(self, self.get_number(at_1)); [INFO] [stderr] 1689 | | let n2 = try_or_fail!(self, self.get_number(at_2)); [INFO] [stderr] ... | [INFO] [stderr] 1772 | | } [INFO] [stderr] 1773 | | } [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] 1686 | match *inlined { [INFO] [stderr] 1687 | InlinedClauseType::CompareNumber(cmp, ref at_1, ref at_2) => { [INFO] [stderr] 1688 | let n1 = try_or_fail!(self, self.get_number(at_1)); [INFO] [stderr] 1689 | let n2 = try_or_fail!(self, self.get_number(at_2)); [INFO] [stderr] 1690 | [INFO] [stderr] 1691 | self.compare_numbers(cmp, n1, n2); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1889:54 [INFO] [stderr] | [INFO] [stderr] 1889 | pub(super) fn to_list>(&mut self, values: Iter) -> usize { [INFO] [stderr] | ^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2103:44 [INFO] [stderr] | [INFO] [stderr] 2103 | self.and_stack[index].cp = self.cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2113:41 [INFO] [stderr] | [INFO] [stderr] 2113 | self.and_stack.push(gi, self.e, self.cp.clone(), num_cells); [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2120:19 [INFO] [stderr] | [INFO] [stderr] 2120 | self.cp = self.and_stack[e].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.and_stack[e].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2127:40 [INFO] [stderr] | [INFO] [stderr] 2127 | call_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2128:40 [INFO] [stderr] | [INFO] [stderr] 2128 | cut_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: try: `&mut CutPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: this function has too many arguments (8/7) [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2126:5 [INFO] [stderr] | [INFO] [stderr] 2126 | / fn handle_call_clause(&mut self, indices: &mut IndexStore, [INFO] [stderr] 2127 | | call_policy: &mut Box, [INFO] [stderr] 2128 | | cut_policy: &mut Box, [INFO] [stderr] 2129 | | ct: &ClauseType, [INFO] [stderr] ... | [INFO] [stderr] 2157 | | }; [INFO] [stderr] 2158 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2143:9 [INFO] [stderr] | [INFO] [stderr] 2143 | / match ct { [INFO] [stderr] 2144 | | &ClauseType::BuiltIn(ref ct) => [INFO] [stderr] 2145 | | try_or_fail!(self, call_policy.call_builtin(self, ct, indices)), [INFO] [stderr] 2146 | | &ClauseType::CallN => [INFO] [stderr] ... | [INFO] [stderr] 2156 | | try_or_fail!(self, self.system_call(ct, indices, call_policy, cut_policy)) [INFO] [stderr] 2157 | | }; [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] 2143 | match *ct { [INFO] [stderr] 2144 | ClauseType::BuiltIn(ref ct) => [INFO] [stderr] 2145 | try_or_fail!(self, call_policy.call_builtin(self, ct, indices)), [INFO] [stderr] 2146 | ClauseType::CallN => [INFO] [stderr] 2147 | try_or_fail!(self, call_policy.call_n(self, arity, indices)), [INFO] [stderr] 2148 | ClauseType::Hook(ref hook) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2161:51 [INFO] [stderr] | [INFO] [stderr] 2161 | call_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2162:51 [INFO] [stderr] | [INFO] [stderr] 2162 | cut_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: try: `&mut CutPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2165:9 [INFO] [stderr] | [INFO] [stderr] 2165 | / match instr { [INFO] [stderr] 2166 | | &ControlInstruction::Allocate(num_cells) => [INFO] [stderr] 2167 | | self.allocate(num_cells), [INFO] [stderr] 2168 | | &ControlInstruction::CallClause(ref ct, arity, _, lco, use_default_cp) => [INFO] [stderr] ... | [INFO] [stderr] 2182 | | self.p = CodePtr::Local(self.cp.clone()) [INFO] [stderr] 2183 | | }; [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] 2165 | match *instr { [INFO] [stderr] 2166 | ControlInstruction::Allocate(num_cells) => [INFO] [stderr] 2167 | self.allocate(num_cells), [INFO] [stderr] 2168 | ControlInstruction::CallClause(ref ct, arity, _, lco, use_default_cp) => [INFO] [stderr] 2169 | self.handle_call_clause(indices, call_policy, cut_policy, [INFO] [stderr] 2170 | ct, arity, lco, use_default_cp), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2182:41 [INFO] [stderr] | [INFO] [stderr] 2182 | self.p = CodePtr::Local(self.cp.clone()) [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2187:61 [INFO] [stderr] | [INFO] [stderr] 2187 | call_policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2189:9 [INFO] [stderr] | [INFO] [stderr] 2189 | / match instr { [INFO] [stderr] 2190 | | &IndexedChoiceInstruction::Try(l) => { [INFO] [stderr] 2191 | | let n = self.num_of_args; [INFO] [stderr] 2192 | | let gi = self.next_global_index(); [INFO] [stderr] ... | [INFO] [stderr] 2218 | | try_or_fail!(self, call_policy.trust(self, l)) [INFO] [stderr] 2219 | | }; [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] 2189 | match *instr { [INFO] [stderr] 2190 | IndexedChoiceInstruction::Try(l) => { [INFO] [stderr] 2191 | let n = self.num_of_args; [INFO] [stderr] 2192 | let gi = self.next_global_index(); [INFO] [stderr] 2193 | [INFO] [stderr] 2194 | self.or_stack.push(gi, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2196:36 [INFO] [stderr] | [INFO] [stderr] 2196 | self.cp.clone(), [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2208:26 [INFO] [stderr] | [INFO] [stderr] 2208 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2223:53 [INFO] [stderr] | [INFO] [stderr] 2223 | call_policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2225:9 [INFO] [stderr] | [INFO] [stderr] 2225 | / match instr { [INFO] [stderr] 2226 | | &ChoiceInstruction::TryMeElse(offset) => { [INFO] [stderr] 2227 | | let n = self.num_of_args; [INFO] [stderr] 2228 | | let gi = self.next_global_index(); [INFO] [stderr] ... | [INFO] [stderr] 2262 | | try_or_fail!(self, call_policy.trust_me(self)) [INFO] [stderr] 2263 | | } [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] 2225 | match *instr { [INFO] [stderr] 2226 | ChoiceInstruction::TryMeElse(offset) => { [INFO] [stderr] 2227 | let n = self.num_of_args; [INFO] [stderr] 2228 | let gi = self.next_global_index(); [INFO] [stderr] 2229 | [INFO] [stderr] 2230 | self.or_stack.push(gi, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2232:36 [INFO] [stderr] | [INFO] [stderr] 2232 | self.cp.clone(), [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2244:26 [INFO] [stderr] | [INFO] [stderr] 2244 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2267:49 [INFO] [stderr] | [INFO] [stderr] 2267 | cut_policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: try: `&mut CutPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2269:9 [INFO] [stderr] | [INFO] [stderr] 2269 | / match instr { [INFO] [stderr] 2270 | | &CutInstruction::NeckCut => { [INFO] [stderr] 2271 | | let b = self.b; [INFO] [stderr] 2272 | | let b0 = self.b0; [INFO] [stderr] ... | [INFO] [stderr] 2298 | | } [INFO] [stderr] 2299 | | } [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] 2269 | match *instr { [INFO] [stderr] 2270 | CutInstruction::NeckCut => { [INFO] [stderr] 2271 | let b = self.b; [INFO] [stderr] 2272 | let b0 = self.b0; [INFO] [stderr] 2273 | [INFO] [stderr] 2274 | if b > b0 { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/system_calls.rs:185:37 [INFO] [stderr] | [INFO] [stderr] 185 | self.p = CodePtr::Local(self.cp.clone()); [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/system_calls.rs:193:44 [INFO] [stderr] | [INFO] [stderr] 193 | call_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/system_calls.rs:194:44 [INFO] [stderr] | [INFO] [stderr] 194 | cut_policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: try: `&mut CutPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 32 [INFO] [stderr] --> src/prolog/machine/system_calls.rs:191:5 [INFO] [stderr] | [INFO] [stderr] 191 | / pub(super) fn system_call(&mut self, ct: &SystemClauseType, [INFO] [stderr] 192 | | indices: &IndexStore, [INFO] [stderr] 193 | | call_policy: &mut Box, [INFO] [stderr] 194 | | cut_policy: &mut Box) [INFO] [stderr] ... | [INFO] [stderr] 518 | | Ok(()) [INFO] [stderr] 519 | | } [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/system_calls.rs:197:9 [INFO] [stderr] | [INFO] [stderr] 197 | / match ct { [INFO] [stderr] 198 | | &SystemClauseType::CheckCutPoint => { [INFO] [stderr] 199 | | let addr = self.store(self.deref(self[temp_v!(1)].clone())); [INFO] [stderr] 200 | | [INFO] [stderr] ... | [INFO] [stderr] 513 | | } [INFO] [stderr] 514 | | }; [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] 197 | match *ct { [INFO] [stderr] 198 | SystemClauseType::CheckCutPoint => { [INFO] [stderr] 199 | let addr = self.store(self.deref(self[temp_v!(1)].clone())); [INFO] [stderr] 200 | [INFO] [stderr] 201 | match addr { [INFO] [stderr] 202 | Addr::Con(Constant::Usize(old_b)) if self.b <= old_b + 2 => {}, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> src/prolog/machine/system_calls.rs:404:20 [INFO] [stderr] | [INFO] [stderr] 404 | if self.ball.stub.len() > 0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!self.ball.stub.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: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/system_calls.rs:499:17 [INFO] [stderr] | [INFO] [stderr] 499 | / if let &Addr::Con(Constant::Atom(ref name, ..)) = &ignore_ops { [INFO] [stderr] 500 | | printer.ignore_ops = name.as_str() == "true"; [INFO] [stderr] 501 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 499 | if let Addr::Con(Constant::Atom(ref name, ..)) = ignore_ops { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/system_calls.rs:503:17 [INFO] [stderr] | [INFO] [stderr] 503 | / if let &Addr::Con(Constant::Atom(ref name, ..)) = &numbervars { [INFO] [stderr] 504 | | printer.numbervars = name.as_str() == "true"; [INFO] [stderr] 505 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 503 | if let Addr::Con(Constant::Atom(ref name, ..)) = numbervars { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/system_calls.rs:507:17 [INFO] [stderr] | [INFO] [stderr] 507 | / if let &Addr::Con(Constant::Atom(ref name, ..)) = "ed { [INFO] [stderr] 508 | | printer.quoted = name.as_str() == "true"; [INFO] [stderr] 509 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 507 | if let Addr::Con(Constant::Atom(ref name, ..)) = quoted { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:43:9 [INFO] [stderr] | [INFO] [stderr] 43 | / match self { [INFO] [stderr] 44 | | &RefOrOwned::Borrowed(r) => r, [INFO] [stderr] 45 | | &RefOrOwned::Owned(ref r) => r [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] 43 | match *self { [INFO] [stderr] 44 | RefOrOwned::Borrowed(r) => r, [INFO] [stderr] 45 | RefOrOwned::Owned(ref r) => r [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:162:9 [INFO] [stderr] | [INFO] [stderr] 162 | / match p { [INFO] [stderr] 163 | | &CodePtr::Local(LocalCodePtr::UserGoalExpansion(p)) => [INFO] [stderr] 164 | | if p < self.goal_expanders.len() { [INFO] [stderr] 165 | | Some(RefOrOwned::Borrowed(&self.goal_expanders[p])) [INFO] [stderr] ... | [INFO] [stderr] 194 | | } [INFO] [stderr] 195 | | } [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] 162 | match *p { [INFO] [stderr] 163 | CodePtr::Local(LocalCodePtr::UserGoalExpansion(p)) => [INFO] [stderr] 164 | if p < self.goal_expanders.len() { [INFO] [stderr] 165 | Some(RefOrOwned::Borrowed(&self.goal_expanders[p])) [INFO] [stderr] 166 | } else { [INFO] [stderr] 167 | None [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> src/prolog/machine/mod.rs:382:12 [INFO] [stderr] | [INFO] [stderr] 382 | if self.machine_st.ball.stub.len() > 0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!self.machine_st.ball.stub.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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:472:9 [INFO] [stderr] | [INFO] [stderr] 472 | / match instr.as_ref() { [INFO] [stderr] 473 | | &Line::Arithmetic(ref arith_instr) => [INFO] [stderr] 474 | | self.execute_arith_instr(arith_instr), [INFO] [stderr] 475 | | &Line::Choice(ref choice_instr) => [INFO] [stderr] ... | [INFO] [stderr] 507 | | } [INFO] [stderr] 508 | | } [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] 472 | match *instr.as_ref() { [INFO] [stderr] 473 | Line::Arithmetic(ref arith_instr) => [INFO] [stderr] 474 | self.execute_arith_instr(arith_instr), [INFO] [stderr] 475 | Line::Choice(ref choice_instr) => [INFO] [stderr] 476 | self.execute_choice_instr(choice_instr, &mut policies.call_policy), [INFO] [stderr] 477 | Line::Cut(ref cut_instr) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:563:13 [INFO] [stderr] | [INFO] [stderr] 563 | / match var_data { [INFO] [stderr] 564 | | &VarData::Perm(p) if p > 0 => { [INFO] [stderr] 565 | | let e = self.e; [INFO] [stderr] 566 | | let r = var_data.as_reg_type().reg_num(); [INFO] [stderr] ... | [INFO] [stderr] 579 | | _ => {} [INFO] [stderr] 580 | | } [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] 563 | match *var_data { [INFO] [stderr] 564 | VarData::Perm(p) if p > 0 => { [INFO] [stderr] 565 | let e = self.e; [INFO] [stderr] 566 | let r = var_data.as_reg_type().reg_num(); [INFO] [stderr] 567 | let addr = self.and_stack[e][r].clone(); [INFO] [stderr] 568 | [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:593:17 [INFO] [stderr] | [INFO] [stderr] 593 | / match &code_repo[LocalCodePtr::TopLevel(cn, p)] { [INFO] [stderr] 594 | | &Line::Control(ref ctrl_instr) if ctrl_instr.is_jump_instr() => { [INFO] [stderr] 595 | | self.record_var_places(cn, alloc_locs, heap_locs); [INFO] [stderr] 596 | | cn += 1; [INFO] [stderr] 597 | | }, [INFO] [stderr] 598 | | _ => {} [INFO] [stderr] 599 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 593 | match code_repo[LocalCodePtr::TopLevel(cn, p)] { [INFO] [stderr] 594 | Line::Control(ref ctrl_instr) if ctrl_instr.is_jump_instr() => { [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/prolog/compile.rs:15:21 [INFO] [stderr] | [INFO] [stderr] 15 | fn print_code(code: &Code) { [INFO] [stderr] | ^^^^^ [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/prolog/compile.rs:17:9 [INFO] [stderr] | [INFO] [stderr] 17 | / match clause { [INFO] [stderr] 18 | | &Line::Arithmetic(ref arith) => [INFO] [stderr] 19 | | println!("{}", arith), [INFO] [stderr] 20 | | &Line::Fact(ref fact) => [INFO] [stderr] ... | [INFO] [stderr] 37 | | } [INFO] [stderr] 38 | | } [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] 17 | match *clause { [INFO] [stderr] 18 | Line::Arithmetic(ref arith) => [INFO] [stderr] 19 | println!("{}", arith), [INFO] [stderr] 20 | Line::Fact(ref fact) => [INFO] [stderr] 21 | for fact_instr in fact { [INFO] [stderr] 22 | println!("{}", fact_instr); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/compile.rs:48:5 [INFO] [stderr] | [INFO] [stderr] 48 | / match tl { [INFO] [stderr] 49 | | &TopLevel::Declaration(_) | &TopLevel::Query(_) => [INFO] [stderr] 50 | | Err(ParserError::ExpectedRel), [INFO] [stderr] 51 | | &TopLevel::Predicate(ref clauses) => [INFO] [stderr] ... | [INFO] [stderr] 56 | | cg.compile_rule(rule) [INFO] [stderr] 57 | | } [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] 48 | match *tl { [INFO] [stderr] 49 | TopLevel::Declaration(_) | TopLevel::Query(_) => [INFO] [stderr] 50 | Err(ParserError::ExpectedRel), [INFO] [stderr] 51 | TopLevel::Predicate(ref clauses) => [INFO] [stderr] 52 | cg.compile_predicate(&clauses.0), [INFO] [stderr] 53 | TopLevel::Fact(ref fact) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/compile.rs:68:9 [INFO] [stderr] | [INFO] [stderr] 68 | / match line { [INFO] [stderr] 69 | | &mut Line::Control(ControlInstruction::JmpBy(_, ref mut offset, ..)) if *offset == 0 => { [INFO] [stderr] 70 | | *offset = code_len - idx; [INFO] [stderr] 71 | | break; [INFO] [stderr] 72 | | }, [INFO] [stderr] 73 | | _ => {} [INFO] [stderr] 74 | | }; [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] 68 | match *line { [INFO] [stderr] 69 | Line::Control(ControlInstruction::JmpBy(_, ref mut offset, ..)) if *offset == 0 => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/compile.rs:163:13 [INFO] [stderr] | [INFO] [stderr] 163 | / if let &mut Some(ref mut module) = &mut self.module { [INFO] [stderr] 164 | | module.remove_module(mod_name, &submodule); [INFO] [stderr] 165 | | module.use_module(&submodule)?; [INFO] [stderr] 166 | | } else { [INFO] [stderr] 167 | | wam_indices.remove_module(clause_name!("user"), &submodule); [INFO] [stderr] 168 | | } [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] 163 | if let Some(ref mut module) = *(&mut self.module) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:170:16 [INFO] [stderr] | [INFO] [stderr] 170 | Ok(wam_indices.insert_module(submodule)) [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] 170 | Ok(()) [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/prolog/compile.rs:176:72 [INFO] [stderr] | [INFO] [stderr] 176 | fn use_qualified_module(&mut self, submodule: ClauseName, exports: &Vec, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateKey]` [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/prolog/compile.rs:185:13 [INFO] [stderr] | [INFO] [stderr] 185 | / if let &mut Some(ref mut module) = &mut self.module { [INFO] [stderr] 186 | | module.remove_module(mod_name, &submodule); [INFO] [stderr] 187 | | module.use_qualified_module(&submodule, exports)?; [INFO] [stderr] 188 | | } else { [INFO] [stderr] 189 | | wam_indices.remove_module(clause_name!("user"), &submodule); [INFO] [stderr] 190 | | } [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] 185 | if let Some(ref mut module) = *(&mut self.module) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:192:16 [INFO] [stderr] | [INFO] [stderr] 192 | Ok(wam_indices.insert_module(submodule)) [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] 192 | Ok(()) [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: use of `or_insert` followed by a function call [INFO] [stderr] --> src/prolog/compile.rs:225:53 [INFO] [stderr] | [INFO] [stderr] 225 | let idx = code_dir.entry((name, arity)).or_insert(CodeIndex::default()); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(CodeIndex::default)` [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: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:278:28 [INFO] [stderr] | [INFO] [stderr] 278 | Ok(code_repo.term_expanders = code), [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] 278 | Ok(()), [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:280:28 [INFO] [stderr] | [INFO] [stderr] 280 | Ok(code_repo.goal_expanders = code) [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] 280 | Ok(()) [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:284:20 [INFO] [stderr] | [INFO] [stderr] 284 | Ok(self.add_non_counted_bt_flag(name, arity)), [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] 284 | Ok(()), [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:296:24 [INFO] [stderr] | [INFO] [stderr] 296 | Ok(self.module = Some(Module::new(module_decl, atom_tbl))) [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] 296 | Ok(()) [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/compile.rs:328:17 [INFO] [stderr] | [INFO] [stderr] 328 | / if let &Some(ref module) = &self.module { [INFO] [stderr] 329 | | worker.term_stream.set_atom_tbl(module.atom_tbl.clone()); [INFO] [stderr] 330 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 328 | if let Some(ref module) = self.module { [INFO] [stderr] | ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/arithmetic.rs:21:21 [INFO] [stderr] | [INFO] [stderr] 21 | let state = match term { [INFO] [stderr] | _____________________^ [INFO] [stderr] 22 | | &Term::AnonVar => [INFO] [stderr] 23 | | return Err(ArithmeticError::InvalidTerm), [INFO] [stderr] 24 | | &Term::Clause(ref cell, ref name, ref terms, fixity) => [INFO] [stderr] ... | [INFO] [stderr] 35 | | TermIterState::Var(Level::Shallow, cell, var.clone()) [INFO] [stderr] 36 | | }; [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] 21 | let state = match *term { [INFO] [stderr] 22 | Term::AnonVar => [INFO] [stderr] 23 | return Err(ArithmeticError::InvalidTerm), [INFO] [stderr] 24 | Term::Clause(ref cell, ref name, ref terms, fixity) => [INFO] [stderr] 25 | match ClauseType::from(name.clone(), terms.len(), fixity) { [INFO] [stderr] 26 | ct @ ClauseType::Named(..) | ct @ ClauseType::Op(..) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/arithmetic.rs:192:9 [INFO] [stderr] | [INFO] [stderr] 192 | / match c { [INFO] [stderr] 193 | | &Constant::Number(ref n) => [INFO] [stderr] 194 | | self.interm.push(ArithmeticTerm::Number(n.clone())), [INFO] [stderr] 195 | | _ => [INFO] [stderr] 196 | | return Err(ArithmeticError::InvalidAtom), [INFO] [stderr] 197 | | } [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] 192 | match *c { [INFO] [stderr] 193 | Constant::Number(ref n) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/codegen.rs:71:34 [INFO] [stderr] | [INFO] [stderr] 71 | fn get_var_count(&self, var: &'a Var) -> usize { [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: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise [INFO] [stderr] --> src/prolog/codegen.rs:72:10 [INFO] [stderr] | [INFO] [stderr] 72 | *self.var_count.get(var).unwrap() [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&self.var_count[var]` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::get_unwrap)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:117:9 [INFO] [stderr] | [INFO] [stderr] 117 | / match subterm { [INFO] [stderr] 118 | | &Term::AnonVar if is_exposed => [INFO] [stderr] 119 | | self.marker.mark_anon_var(Level::Deep, target), [INFO] [stderr] 120 | | &Term::AnonVar => [INFO] [stderr] ... | [INFO] [stderr] 133 | | } [INFO] [stderr] 134 | | }; [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] 117 | match *subterm { [INFO] [stderr] 118 | Term::AnonVar if is_exposed => [INFO] [stderr] 119 | self.marker.mark_anon_var(Level::Deep, target), [INFO] [stderr] 120 | Term::AnonVar => [INFO] [stderr] 121 | Self::add_or_increment_void_instr(target), [INFO] [stderr] 122 | Term::Cons(ref cell, _, _) | Term::Clause(ref cell, _, _, _) => { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:195:32 [INFO] [stderr] | [INFO] [stderr] 195 | let term_loc = match chunked_term { [INFO] [stderr] | ________________________________^ [INFO] [stderr] 196 | | &ChunkedTerm::HeadClause(..) => GenContext::Head, [INFO] [stderr] 197 | | &ChunkedTerm::BodyTerm(_) => if i < chunked_terms.len() - 1 { [INFO] [stderr] 198 | | GenContext::Mid(chunk_num) [INFO] [stderr] ... | [INFO] [stderr] 201 | | } [INFO] [stderr] 202 | | }; [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] 195 | let term_loc = match *chunked_term { [INFO] [stderr] 196 | ChunkedTerm::HeadClause(..) => GenContext::Head, [INFO] [stderr] 197 | ChunkedTerm::BodyTerm(_) => if i < chunked_terms.len() - 1 { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:222:9 [INFO] [stderr] | [INFO] [stderr] 222 | / match qt { [INFO] [stderr] 223 | | &QueryTerm::Jump(ref vars) => [INFO] [stderr] 224 | | code.push(jmp_call!(vars.len(), 0, pvs)), [INFO] [stderr] 225 | | &QueryTerm::Clause(_, ref ct, ref terms, true) => [INFO] [stderr] ... | [INFO] [stderr] 229 | | _ => {} [INFO] [stderr] 230 | | } [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] 222 | match *qt { [INFO] [stderr] 223 | QueryTerm::Jump(ref vars) => [INFO] [stderr] 224 | code.push(jmp_call!(vars.len(), 0, pvs)), [INFO] [stderr] 225 | QueryTerm::Clause(_, ref ct, ref terms, true) => [INFO] [stderr] 226 | code.push(call_clause_by_default!(ct.clone(), terms.len(), pvs)), [INFO] [stderr] 227 | QueryTerm::Clause(_, ref ct, ref terms, false) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:239:17 [INFO] [stderr] | [INFO] [stderr] 239 | / match ctrl { [INFO] [stderr] 240 | | &mut ControlInstruction::CallClause(_, _, _, ref mut last_call, _) => [INFO] [stderr] 241 | | *last_call = true, [INFO] [stderr] 242 | | &mut ControlInstruction::JmpBy(_, _, _, ref mut last_call) => [INFO] [stderr] ... | [INFO] [stderr] 245 | | _ => dealloc_index += 1 [INFO] [stderr] 246 | | }, [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] 239 | match *ctrl { [INFO] [stderr] 240 | ControlInstruction::CallClause(_, _, _, ref mut last_call, _) => [INFO] [stderr] 241 | *last_call = true, [INFO] [stderr] 242 | ControlInstruction::JmpBy(_, _, _, ref mut last_call) => [INFO] [stderr] 243 | *last_call = true, [INFO] [stderr] 244 | ControlInstruction::Proceed => {}, [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/prolog/codegen.rs:255:66 [INFO] [stderr] | [INFO] [stderr] 255 | fn compile_inlined(&mut self, ct: &InlinedClauseType, terms: &'a Vec>, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/codegen.rs:259:9 [INFO] [stderr] | [INFO] [stderr] 259 | / match ct { [INFO] [stderr] 260 | | &InlinedClauseType::CompareNumber(cmp, ..) => { [INFO] [stderr] 261 | | let (mut lcode, at_1) = self.call_arith_eval(terms[0].as_ref(), 1)?; [INFO] [stderr] 262 | | let (mut rcode, at_2) = self.call_arith_eval(terms[1].as_ref(), 2)?; [INFO] [stderr] ... | [INFO] [stderr] 396 | | } [INFO] [stderr] 397 | | } [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] 259 | match *ct { [INFO] [stderr] 260 | InlinedClauseType::CompareNumber(cmp, ..) => { [INFO] [stderr] 261 | let (mut lcode, at_1) = self.call_arith_eval(terms[0].as_ref(), 1)?; [INFO] [stderr] 262 | let (mut rcode, at_2) = self.call_arith_eval(terms[1].as_ref(), 2)?; [INFO] [stderr] 263 | [INFO] [stderr] 264 | code.append(&mut lcode); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:272:17 [INFO] [stderr] | [INFO] [stderr] 272 | / match terms[0].as_ref() { [INFO] [stderr] 273 | | &Term::Constant(_, Constant::Char(_)) [INFO] [stderr] 274 | | | &Term::Constant(_, Constant::Atom(..)) => { [INFO] [stderr] 275 | | code.push(succeed!()); [INFO] [stderr] ... | [INFO] [stderr] 283 | | } [INFO] [stderr] 284 | | }, [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] 272 | match *terms[0].as_ref() { [INFO] [stderr] 273 | Term::Constant(_, Constant::Char(_)) [INFO] [stderr] 274 | | Term::Constant(_, Constant::Atom(..)) => { [INFO] [stderr] 275 | code.push(succeed!()); [INFO] [stderr] 276 | }, [INFO] [stderr] 277 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:286:17 [INFO] [stderr] | [INFO] [stderr] 286 | / match terms[0].as_ref() { [INFO] [stderr] 287 | | &Term::AnonVar | &Term::Clause(..) | &Term::Cons(..) => { [INFO] [stderr] 288 | | code.push(fail!()); [INFO] [stderr] 289 | | }, [INFO] [stderr] ... | [INFO] [stderr] 296 | | } [INFO] [stderr] 297 | | }, [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] 286 | match *terms[0].as_ref() { [INFO] [stderr] 287 | Term::AnonVar | Term::Clause(..) | Term::Cons(..) => { [INFO] [stderr] 288 | code.push(fail!()); [INFO] [stderr] 289 | }, [INFO] [stderr] 290 | Term::Constant(..) => { [INFO] [stderr] 291 | code.push(succeed!()); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:299:17 [INFO] [stderr] | [INFO] [stderr] 299 | / match terms[0].as_ref() { [INFO] [stderr] 300 | | &Term::Clause(..) | &Term::Cons(..) => { [INFO] [stderr] 301 | | code.push(succeed!()); [INFO] [stderr] 302 | | }, [INFO] [stderr] ... | [INFO] [stderr] 309 | | } [INFO] [stderr] 310 | | }, [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] 299 | match *terms[0].as_ref() { [INFO] [stderr] 300 | Term::Clause(..) | Term::Cons(..) => { [INFO] [stderr] 301 | code.push(succeed!()); [INFO] [stderr] 302 | }, [INFO] [stderr] 303 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:312:17 [INFO] [stderr] | [INFO] [stderr] 312 | / match terms[0].as_ref() { [INFO] [stderr] 313 | | &Term::Constant(_, Constant::Number(Number::Rational(_))) => { [INFO] [stderr] 314 | | code.push(succeed!()); [INFO] [stderr] 315 | | }, [INFO] [stderr] ... | [INFO] [stderr] 322 | | } [INFO] [stderr] 323 | | }, [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] 312 | match *terms[0].as_ref() { [INFO] [stderr] 313 | Term::Constant(_, Constant::Number(Number::Rational(_))) => { [INFO] [stderr] 314 | code.push(succeed!()); [INFO] [stderr] 315 | }, [INFO] [stderr] 316 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:325:17 [INFO] [stderr] | [INFO] [stderr] 325 | / match terms[0].as_ref() { [INFO] [stderr] 326 | | &Term::Constant(_, Constant::Number(Number::Float(_))) => { [INFO] [stderr] 327 | | code.push(succeed!()); [INFO] [stderr] 328 | | }, [INFO] [stderr] ... | [INFO] [stderr] 335 | | } [INFO] [stderr] 336 | | }, [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] 325 | match *terms[0].as_ref() { [INFO] [stderr] 326 | Term::Constant(_, Constant::Number(Number::Float(_))) => { [INFO] [stderr] 327 | code.push(succeed!()); [INFO] [stderr] 328 | }, [INFO] [stderr] 329 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:338:17 [INFO] [stderr] | [INFO] [stderr] 338 | / match terms[0].as_ref() { [INFO] [stderr] 339 | | &Term::Constant(_, Constant::String(_)) => { [INFO] [stderr] 340 | | code.push(succeed!()); [INFO] [stderr] 341 | | }, [INFO] [stderr] ... | [INFO] [stderr] 348 | | } [INFO] [stderr] 349 | | }, [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] 338 | match *terms[0].as_ref() { [INFO] [stderr] 339 | Term::Constant(_, Constant::String(_)) => { [INFO] [stderr] 340 | code.push(succeed!()); [INFO] [stderr] 341 | }, [INFO] [stderr] 342 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:351:17 [INFO] [stderr] | [INFO] [stderr] 351 | / match terms[0].as_ref() { [INFO] [stderr] 352 | | &Term::AnonVar => { [INFO] [stderr] 353 | | code.push(fail!()); [INFO] [stderr] 354 | | }, [INFO] [stderr] ... | [INFO] [stderr] 361 | | } [INFO] [stderr] 362 | | }, [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] 351 | match *terms[0].as_ref() { [INFO] [stderr] 352 | Term::AnonVar => { [INFO] [stderr] 353 | code.push(fail!()); [INFO] [stderr] 354 | }, [INFO] [stderr] 355 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:364:17 [INFO] [stderr] | [INFO] [stderr] 364 | / match terms[0].as_ref() { [INFO] [stderr] 365 | | &Term::Constant(_, Constant::Number(Number::Integer(_))) => { [INFO] [stderr] 366 | | code.push(succeed!()); [INFO] [stderr] 367 | | }, [INFO] [stderr] ... | [INFO] [stderr] 374 | | }, [INFO] [stderr] 375 | | }, [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] 364 | match *terms[0].as_ref() { [INFO] [stderr] 365 | Term::Constant(_, Constant::Number(Number::Integer(_))) => { [INFO] [stderr] 366 | code.push(succeed!()); [INFO] [stderr] 367 | }, [INFO] [stderr] 368 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:377:17 [INFO] [stderr] | [INFO] [stderr] 377 | / match terms[0].as_ref() { [INFO] [stderr] 378 | | &Term::Constant(..) | &Term::Clause(..) | &Term::Cons(..) => { [INFO] [stderr] 379 | | code.push(fail!()); [INFO] [stderr] 380 | | }, [INFO] [stderr] ... | [INFO] [stderr] 387 | | } [INFO] [stderr] 388 | | }, [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] 377 | match *terms[0].as_ref() { [INFO] [stderr] 378 | Term::Constant(..) | Term::Clause(..) | Term::Cons(..) => { [INFO] [stderr] 379 | code.push(fail!()); [INFO] [stderr] 380 | }, [INFO] [stderr] 381 | Term::AnonVar => { [INFO] [stderr] 382 | code.push(succeed!()); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:390:17 [INFO] [stderr] | [INFO] [stderr] 390 | / match terms[0].as_ref() { [INFO] [stderr] 391 | | &Term::Var(ref vr, ref name) => { [INFO] [stderr] 392 | | let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code); [INFO] [stderr] 393 | | code.push(is_partial_string!(r)); [INFO] [stderr] 394 | | }, [INFO] [stderr] 395 | | _ => code.push(fail!()) [INFO] [stderr] 396 | | } [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] 390 | match *terms[0].as_ref() { [INFO] [stderr] 391 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:420:17 [INFO] [stderr] | [INFO] [stderr] 420 | / match *term { [INFO] [stderr] 421 | | &QueryTerm::GetLevelAndUnify(ref cell, ref var) => { [INFO] [stderr] 422 | | let mut target = Vec::new(); [INFO] [stderr] 423 | | [INFO] [stderr] ... | [INFO] [stderr] 493 | | }, [INFO] [stderr] 494 | | }; [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] 420 | match *(*term) { [INFO] [stderr] 421 | QueryTerm::GetLevelAndUnify(ref cell, ref var) => { [INFO] [stderr] 422 | let mut target = Vec::new(); [INFO] [stderr] 423 | [INFO] [stderr] 424 | self.marker.reset_arg(1); [INFO] [stderr] 425 | self.marker.mark_var(var.clone(), Level::Shallow, cell, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:449:25 [INFO] [stderr] | [INFO] [stderr] 449 | / match terms[0].as_ref() { [INFO] [stderr] 450 | | &Term::Var(ref vr, ref name) => { [INFO] [stderr] 451 | | let mut target = Vec::new(); [INFO] [stderr] 452 | | [INFO] [stderr] ... | [INFO] [stderr] 480 | | } [INFO] [stderr] 481 | | } [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] 449 | match *terms[0].as_ref() { [INFO] [stderr] 450 | Term::Var(ref vr, ref name) => { [INFO] [stderr] 451 | let mut target = Vec::new(); [INFO] [stderr] 452 | [INFO] [stderr] 453 | self.marker.reset_arg(2); [INFO] [stderr] 454 | self.marker.mark_var(name.clone(), Level::Shallow, vr, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:519:9 [INFO] [stderr] | [INFO] [stderr] 519 | / match toc { [INFO] [stderr] 520 | | &QueryTerm::BlockedCut | &QueryTerm::UnblockedCut(..) => code.push(proceed!()), [INFO] [stderr] 521 | | &QueryTerm::Clause(_, ClauseType::Inlined(..), ..) => code.push(proceed!()), [INFO] [stderr] 522 | | _ => {} [INFO] [stderr] 523 | | }; [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] 519 | match *toc { [INFO] [stderr] 520 | QueryTerm::BlockedCut | QueryTerm::UnblockedCut(..) => code.push(proceed!()), [INFO] [stderr] 521 | QueryTerm::Clause(_, ClauseType::Inlined(..), ..) => code.push(proceed!()), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:555:25 [INFO] [stderr] | [INFO] [stderr] 555 | let index = if let &Line::Control(_) = code.last().unwrap() { [INFO] [stderr] | _________________________^ [INFO] [stderr] 556 | | code.len() - 2 [INFO] [stderr] 557 | | } else { [INFO] [stderr] 558 | | code.len() - 1 [INFO] [stderr] 559 | | }; [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] 555 | let index = if let Line::Control(_) = *code.last().unwrap() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:561:13 [INFO] [stderr] | [INFO] [stderr] 561 | / if let &mut Line::Query(ref mut query) = &mut code[index] { [INFO] [stderr] 562 | | let head_iter = FactIterator::from_rule_head_clause(args); [INFO] [stderr] 563 | | conjunct_info.perm_vs.mark_unsafe_vars_in_rule(head_iter, query); [INFO] [stderr] 564 | | } [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] 561 | if let Line::Query(ref mut query) = *(&mut code[index]) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:580:13 [INFO] [stderr] | [INFO] [stderr] 580 | / match fact_instr { [INFO] [stderr] 581 | | &mut FactInstruction::UnifyValue(reg) => [INFO] [stderr] 582 | | if let Some(found) = unsafe_vars.get_mut(®) { [INFO] [stderr] 583 | | if !*found { [INFO] [stderr] ... | [INFO] [stderr] 593 | | _ => {} [INFO] [stderr] 594 | | }; [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] 580 | match *fact_instr { [INFO] [stderr] 581 | FactInstruction::UnifyValue(reg) => [INFO] [stderr] 582 | if let Some(found) = unsafe_vars.get_mut(®) { [INFO] [stderr] 583 | if !*found { [INFO] [stderr] 584 | *found = true; [INFO] [stderr] 585 | *fact_instr = FactInstruction::UnifyLocalValue(reg); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:610:9 [INFO] [stderr] | [INFO] [stderr] 610 | / if let &Term::Clause(_, _, ref args, _) = term { [INFO] [stderr] 611 | | self.marker.reset_at_head(args); [INFO] [stderr] 612 | | [INFO] [stderr] 613 | | let iter = FactInstruction::iter(term); [INFO] [stderr] ... | [INFO] [stderr] 620 | | } [INFO] [stderr] 621 | | } [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] 610 | if let Term::Clause(_, _, ref args, _) = *term { [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/prolog/codegen.rs:642:44 [INFO] [stderr] | [INFO] [stderr] 642 | pub fn compile_query(&mut self, query: &'a Vec) -> Result [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[QueryTerm]` [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/prolog/codegen.rs:654:25 [INFO] [stderr] | [INFO] [stderr] 654 | let index = if let &Line::Control(_) = code.last().unwrap() { [INFO] [stderr] | _________________________^ [INFO] [stderr] 655 | | code.len() - 2 [INFO] [stderr] 656 | | } else { [INFO] [stderr] 657 | | code.len() - 1 [INFO] [stderr] 658 | | }; [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] 654 | let index = if let Line::Control(_) = *code.last().unwrap() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:660:13 [INFO] [stderr] | [INFO] [stderr] 660 | / if let &mut Line::Query(ref mut query) = &mut code[index] { [INFO] [stderr] 661 | | conjunct_info.perm_vs.mark_unsafe_vars_in_query(query); [INFO] [stderr] 662 | | } [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] 660 | if let Line::Query(ref mut query) = *(&mut code[index]) { [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/prolog/codegen.rs:672:33 [INFO] [stderr] | [INFO] [stderr] 672 | fn split_predicate(clauses: &Vec) -> Vec<(usize, usize)> [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateClause]` [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/prolog/codegen.rs:725:35 [INFO] [stderr] | [INFO] [stderr] 725 | let mut clause_code = match clause { [INFO] [stderr] | ___________________________________^ [INFO] [stderr] 726 | | &PredicateClause::Fact(ref fact) => [INFO] [stderr] 727 | | self.compile_fact(fact), [INFO] [stderr] 728 | | &PredicateClause::Rule(ref rule) => [INFO] [stderr] 729 | | try!(self.compile_rule(rule)) [INFO] [stderr] 730 | | }; [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] 725 | let mut clause_code = match *clause { [INFO] [stderr] 726 | PredicateClause::Fact(ref fact) => [INFO] [stderr] 727 | self.compile_fact(fact), [INFO] [stderr] 728 | PredicateClause::Rule(ref rule) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: called `map(f)` on an Option value where `f` is a unit closure [INFO] [stderr] --> src/prolog/codegen.rs:742:13 [INFO] [stderr] | [INFO] [stderr] 742 | clause.first_arg().map(|arg| { [INFO] [stderr] | _____________^ [INFO] [stderr] | |_____________| [INFO] [stderr] | || [INFO] [stderr] 743 | || let index = code_body.len(); [INFO] [stderr] 744 | || code_offsets.index_term(arg, index); [INFO] [stderr] 745 | || }); [INFO] [stderr] | ||______________^- help: try this: `if let Some(arg) = clause.first_arg() { ... }` [INFO] [stderr] | |_______________| [INFO] [stderr] | [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::option_map_unit_fn)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn [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/prolog/codegen.rs:756:58 [INFO] [stderr] | [INFO] [stderr] 756 | pub fn compile_predicate<'b: 'a>(&mut self, clauses: &'b Vec) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateClause]` [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/prolog/debray_allocator.rs:21:46 [INFO] [stderr] | [INFO] [stderr] 21 | fn is_curr_arg_distinct_from(&self, var: &Var) -> 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: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/debray_allocator.rs:28:45 [INFO] [stderr] | [INFO] [stderr] 28 | fn occurs_shallowly_in_head(&self, var: &Var, r: usize) -> 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/prolog/debray_allocator.rs:30:9 [INFO] [stderr] | [INFO] [stderr] 30 | / match self.bindings.get(var).unwrap() { [INFO] [stderr] 31 | | &VarData::Temp(_, _, ref tvd) => [INFO] [stderr] 32 | | tvd.use_set.contains(&(GenContext::Head, r)), [INFO] [stderr] 33 | | _ => false [INFO] [stderr] 34 | | } [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] 30 | match *self.bindings.get(var).unwrap() { [INFO] [stderr] 31 | VarData::Temp(_, _, ref tvd) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise [INFO] [stderr] --> src/prolog/debray_allocator.rs:30:15 [INFO] [stderr] | [INFO] [stderr] 30 | match self.bindings.get(var).unwrap() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&self.bindings[var]` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/debray_allocator.rs:42:34 [INFO] [stderr] | [INFO] [stderr] 42 | fn alloc_with_cr(&self, var: &Var) -> usize [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/prolog/debray_allocator.rs:69:34 [INFO] [stderr] | [INFO] [stderr] 69 | fn alloc_with_ca(&self, var: &Var) -> usize [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: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise [INFO] [stderr] --> src/prolog/debray_allocator.rs:111:27 [INFO] [stderr] | [INFO] [stderr] 111 | let tvd = self.bindings.get(t_var).unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&self.bindings[t_var]` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/debray_allocator.rs:112:17 [INFO] [stderr] | [INFO] [stderr] 112 | / if let &VarData::Temp(_, _, ref tvd) = tvd { [INFO] [stderr] 113 | | if !tvd.use_set.contains(&(GenContext::Last(chunk_num), k)) { [INFO] [stderr] 114 | | return Some((t_var.clone(), self.alloc_with_ca(t_var))); [INFO] [stderr] 115 | | } [INFO] [stderr] 116 | | } [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] 112 | if let VarData::Temp(_, _, ref tvd) = *tvd { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/debray_allocator.rs:127:9 [INFO] [stderr] | [INFO] [stderr] 127 | / match self.alloc_in_last_goal_hint(chunk_num) { [INFO] [stderr] 128 | | Some((var, r)) => { [INFO] [stderr] 129 | | let k = self.arg_c; [INFO] [stderr] 130 | | [INFO] [stderr] ... | [INFO] [stderr] 143 | | _ => {} [INFO] [stderr] 144 | | }; [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 127 | if let Some((var, r)) = self.alloc_in_last_goal_hint(chunk_num) { [INFO] [stderr] 128 | let k = self.arg_c; [INFO] [stderr] 129 | [INFO] [stderr] 130 | if r != k { [INFO] [stderr] 131 | let r = RegType::Temp(r); [INFO] [stderr] 132 | [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/debray_allocator.rs:147:53 [INFO] [stderr] | [INFO] [stderr] 147 | fn alloc_reg_to_var<'a, Target>(&mut self, var: &Var, lvl: Level, term_loc: GenContext, [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/prolog/debray_allocator.rs:188:29 [INFO] [stderr] | [INFO] [stderr] 188 | fn in_place(&self, var: &Var, term_loc: GenContext, r: RegType, k: usize) -> 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/prolog/debray_allocator.rs:192:18 [INFO] [stderr] | [INFO] [stderr] 192 | _ => match self.bindings().get(var).unwrap() { [INFO] [stderr] | __________________^ [INFO] [stderr] 193 | | &VarData::Temp(_, o, _) if r.reg_num() == k => o == k, [INFO] [stderr] 194 | | _ => false [INFO] [stderr] 195 | | } [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] 192 | _ => match *self.bindings().get(var).unwrap() { [INFO] [stderr] 193 | VarData::Temp(_, o, _) if r.reg_num() == k => o == k, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/debray_allocator.rs:358:13 [INFO] [stderr] | [INFO] [stderr] 358 | / if let &Term::Var(_, ref var) = arg.as_ref() { [INFO] [stderr] 359 | | let r = self.get(var.clone()); [INFO] [stderr] 360 | | [INFO] [stderr] 361 | | if !r.is_perm() && r.reg_num() == 0 { [INFO] [stderr] ... | [INFO] [stderr] 365 | | } [INFO] [stderr] 366 | | } [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] 358 | if let Term::Var(_, ref var) = *arg.as_ref() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:41:13 [INFO] [stderr] | [INFO] [stderr] 41 | / if let &mut VarStatus::Temp(_, ref mut var_data) = var_status { [INFO] [stderr] 42 | | let mut use_set = OccurrenceSet::new(); [INFO] [stderr] 43 | | [INFO] [stderr] 44 | | swap(&mut var_data.use_set, &mut use_set); [INFO] [stderr] 45 | | use_sets.insert((*var).clone(), use_set); [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 | if let VarStatus::Temp(_, ref mut var_data) = *var_status { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:54:25 [INFO] [stderr] | [INFO] [stderr] 54 | / if let &mut VarStatus::Temp(cn_t, ref mut t_data) = var_status { [INFO] [stderr] 55 | | if cn_u == cn_t && *u != ***t { [INFO] [stderr] 56 | | if !t_data.uses_reg(reg) { [INFO] [stderr] 57 | | t_data.no_use_set.insert(reg); [INFO] [stderr] 58 | | } [INFO] [stderr] 59 | | } [INFO] [stderr] 60 | | } [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] 54 | if let VarStatus::Temp(cn_t, ref mut t_data) = *var_status { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/fixtures.rs:66:13 [INFO] [stderr] | [INFO] [stderr] 66 | / match self.get_mut(u).unwrap() { [INFO] [stderr] 67 | | &mut (VarStatus::Temp(_, ref mut u_data), _) => { [INFO] [stderr] 68 | | u_data.use_set = use_set; [INFO] [stderr] 69 | | u_data.populate_conflict_set(); [INFO] [stderr] 70 | | }, [INFO] [stderr] 71 | | _ => {} [INFO] [stderr] 72 | | }; [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 66 | if let &mut (VarStatus::Temp(_, ref mut u_data), _) = self.get_mut(u).unwrap() { [INFO] [stderr] 67 | u_data.use_set = use_set; [INFO] [stderr] 68 | u_data.populate_conflict_set(); [INFO] [stderr] 69 | }; [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:66:13 [INFO] [stderr] | [INFO] [stderr] 66 | / match self.get_mut(u).unwrap() { [INFO] [stderr] 67 | | &mut (VarStatus::Temp(_, ref mut u_data), _) => { [INFO] [stderr] 68 | | u_data.use_set = use_set; [INFO] [stderr] 69 | | u_data.populate_conflict_set(); [INFO] [stderr] 70 | | }, [INFO] [stderr] 71 | | _ => {} [INFO] [stderr] 72 | | }; [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] 66 | match *self.get_mut(u).unwrap() { [INFO] [stderr] 67 | (VarStatus::Temp(_, ref mut u_data), _) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:102:13 [INFO] [stderr] | [INFO] [stderr] 102 | / if let &VarStatus::Perm(i) = var_status { [INFO] [stderr] 103 | | if i > index { [INFO] [stderr] 104 | | var_count += 1; [INFO] [stderr] 105 | | } [INFO] [stderr] 106 | | } [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] 102 | if let VarStatus::Perm(i) = *var_status { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/fixtures.rs:119:13 [INFO] [stderr] | [INFO] [stderr] 119 | / if let &TermRef::Var(lvl, cell, ref var) = &term_ref { [INFO] [stderr] 120 | | let mut status = self.0.remove(var) [INFO] [stderr] 121 | | .unwrap_or((VarStatus::Temp(chunk_num, TempVarData::new(lt_arity)), [INFO] [stderr] 122 | | Vec::new())); [INFO] [stderr] ... | [INFO] [stderr] 135 | | self.0.insert(var.clone(), status); [INFO] [stderr] 136 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 119 | if let TermRef::Var(lvl, cell, ref var) = term_ref { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/fixtures.rs:160:17 [INFO] [stderr] | [INFO] [stderr] 160 | / match &v.0 { [INFO] [stderr] 161 | | &VarStatus::Perm(i) => Some((i, &v.1)), [INFO] [stderr] 162 | | _ => None [INFO] [stderr] 163 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 160 | match v.0 { [INFO] [stderr] 161 | VarStatus::Perm(i) => Some((i, &v.1)), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:181:13 [INFO] [stderr] | [INFO] [stderr] 181 | / match query_instr { [INFO] [stderr] 182 | | &mut QueryInstruction::PutValue(RegType::Perm(i), arg) => [INFO] [stderr] 183 | | if let Some(found) = unsafe_vars.get_mut(&RegType::Perm(i)) { [INFO] [stderr] 184 | | if !*found { [INFO] [stderr] ... | [INFO] [stderr] 201 | | _ => {} [INFO] [stderr] 202 | | }; [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] 181 | match *query_instr { [INFO] [stderr] 182 | QueryInstruction::PutValue(RegType::Perm(i), arg) => [INFO] [stderr] 183 | if let Some(found) = unsafe_vars.get_mut(&RegType::Perm(i)) { [INFO] [stderr] 184 | if !*found { [INFO] [stderr] 185 | *found = true; [INFO] [stderr] 186 | *query_instr = QueryInstruction::PutUnsafeValue(i, arg); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/fixtures.rs:208:13 [INFO] [stderr] | [INFO] [stderr] 208 | / match cb.first() { [INFO] [stderr] 209 | | Some(index) => { [INFO] [stderr] 210 | | unsafe_vars.insert(index.get().norm(), false); [INFO] [stderr] 211 | | }, [INFO] [stderr] 212 | | None => {} [INFO] [stderr] 213 | | }; [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 208 | if let Some(index) = cb.first() { [INFO] [stderr] 209 | unsafe_vars.insert(index.get().norm(), false); [INFO] [stderr] 210 | }; [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/fixtures.rs:220:13 [INFO] [stderr] | [INFO] [stderr] 220 | / match term_ref { [INFO] [stderr] 221 | | TermRef::Var(Level::Shallow, cell, _) => { [INFO] [stderr] 222 | | unsafe_vars.remove(&cell.get().norm()); [INFO] [stderr] 223 | | }, [INFO] [stderr] 224 | | _ => {} [INFO] [stderr] 225 | | }; [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 220 | if let TermRef::Var(Level::Shallow, cell, _) = term_ref { [INFO] [stderr] 221 | unsafe_vars.remove(&cell.get().norm()); [INFO] [stderr] 222 | }; [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/heap_iter.rs:24:9 [INFO] [stderr] | [INFO] [stderr] 24 | / match &self.machine_st.heap[h] { [INFO] [stderr] 25 | | &HeapCellValue::NamedStr(arity, _, _) => { [INFO] [stderr] 26 | | for idx in (1 .. arity + 1).rev() { [INFO] [stderr] 27 | | self.state_stack.push(Addr::HeapCell(h + idx)); [INFO] [stderr] ... | [INFO] [stderr] 33 | | self.follow(a.clone()) [INFO] [stderr] 34 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 24 | match self.machine_st.heap[h] { [INFO] [stderr] 25 | HeapCellValue::NamedStr(arity, _, _) => { [INFO] [stderr] 26 | for idx in (1 .. arity + 1).rev() { [INFO] [stderr] 27 | self.state_stack.push(Addr::HeapCell(h + idx)); [INFO] [stderr] 28 | } [INFO] [stderr] 29 | [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/heap_iter.rs:26:28 [INFO] [stderr] | [INFO] [stderr] 26 | for idx in (1 .. arity + 1).rev() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: use: `(1..=arity)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> src/prolog/heap_iter.rs:131:5 [INFO] [stderr] | [INFO] [stderr] 131 | / pub fn pre_order_iter<'a>(&'a self, a: Addr) -> HCPreOrderIterator<'a> { [INFO] [stderr] 132 | | HCPreOrderIterator::new(self, a) [INFO] [stderr] 133 | | } [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: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> src/prolog/heap_iter.rs:135:5 [INFO] [stderr] | [INFO] [stderr] 135 | / pub fn post_order_iter<'a>(&'a self, a: Addr) -> HCPostOrderIterator<'a> { [INFO] [stderr] 136 | | HCPostOrderIterator::new(HCPreOrderIterator::new(self, a)) [INFO] [stderr] 137 | | } [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: called `map(f)` on an Option value where `f` is a unit closure [INFO] [stderr] --> src/prolog/indexing.rs:30:9 [INFO] [stderr] | [INFO] [stderr] 30 | / prelude.last_mut().map(|instr| { [INFO] [stderr] 31 | | match instr { [INFO] [stderr] 32 | | &mut IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] 33 | | *instr = IndexedChoiceInstruction::Trust(i), [INFO] [stderr] 34 | | _ => {} [INFO] [stderr] 35 | | }; [INFO] [stderr] 36 | | }); [INFO] [stderr] | |__________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 30 | if let Some(instr) = prelude.last_mut() { match instr { [INFO] [stderr] 31 | &mut IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] 32 | *instr = IndexedChoiceInstruction::Trust(i), [INFO] [stderr] 33 | _ => {} [INFO] [stderr] 34 | }; } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/indexing.rs:31:13 [INFO] [stderr] | [INFO] [stderr] 31 | / match instr { [INFO] [stderr] 32 | | &mut IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] 33 | | *instr = IndexedChoiceInstruction::Trust(i), [INFO] [stderr] 34 | | _ => {} [INFO] [stderr] 35 | | }; [INFO] [stderr] | |_____________^ help: try this: `if let &mut IndexedChoiceInstruction::Retry(i) = instr { *instr = IndexedChoiceInstruction::Trust(i) }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/indexing.rs:31:13 [INFO] [stderr] | [INFO] [stderr] 31 | / match instr { [INFO] [stderr] 32 | | &mut IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] 33 | | *instr = IndexedChoiceInstruction::Trust(i), [INFO] [stderr] 34 | | _ => {} [INFO] [stderr] 35 | | }; [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 *instr { [INFO] [stderr] 32 | IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/indexing.rs:49:9 [INFO] [stderr] | [INFO] [stderr] 49 | / match first_arg { [INFO] [stderr] 50 | | &Term::Clause(_, ref name, ref terms, _) => { [INFO] [stderr] 51 | | let code = self.structures.entry((name.clone(), terms.len())) [INFO] [stderr] 52 | | .or_insert(Vec::new()); [INFO] [stderr] ... | [INFO] [stderr] 73 | | _ => {} [INFO] [stderr] 74 | | }; [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] 49 | match *first_arg { [INFO] [stderr] 50 | Term::Clause(_, ref name, ref terms, _) => { [INFO] [stderr] 51 | let code = self.structures.entry((name.clone(), terms.len())) [INFO] [stderr] 52 | .or_insert(Vec::new()); [INFO] [stderr] 53 | [INFO] [stderr] 54 | let is_initial_index = code.is_empty(); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: use of `or_insert` followed by a function call [INFO] [stderr] --> src/prolog/indexing.rs:52:33 [INFO] [stderr] | [INFO] [stderr] 52 | .or_insert(Vec::new()); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)` [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 `or_insert` followed by a function call [INFO] [stderr] --> src/prolog/indexing.rs:68:33 [INFO] [stderr] | [INFO] [stderr] 68 | .or_insert(Vec::new()); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)` [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: redundant closure found [INFO] [stderr] --> src/prolog/indexing.rs:87:53 [INFO] [stderr] | [INFO] [stderr] 87 | prelude.extend(code.into_iter().map(|code| Line::from(code))); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ help: remove closure as shown: `Line::from` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::redundant_closure)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure [INFO] [stderr] [INFO] [stderr] warning: called `map(f)` on an Option value where `f` is a unit closure [INFO] [stderr] --> src/prolog/indexing.rs:89:17 [INFO] [stderr] | [INFO] [stderr] 89 | code.first().map(|i| { [INFO] [stderr] | _________________^ [INFO] [stderr] | |_________________| [INFO] [stderr] | || [INFO] [stderr] 90 | || index_locs.insert(key, IntIndex::External(i.offset())); [INFO] [stderr] 91 | || }); [INFO] [stderr] | ||__________________^- help: try this: `if let Some(i) = code.first() { index_locs.insert(key, IntIndex::External(i.offset())); }` [INFO] [stderr] | |___________________| [INFO] [stderr] | [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn [INFO] [stderr] [INFO] [stderr] warning: redundant closure found [INFO] [stderr] --> src/prolog/indexing.rs:179:50 [INFO] [stderr] | [INFO] [stderr] 179 | prelude.extend(lists.into_iter().map(|i| Line::from(i))); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ help: remove closure as shown: `Line::from` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/indexing.rs:238:13 [INFO] [stderr] | [INFO] [stderr] 238 | / match line { [INFO] [stderr] 239 | | &mut Line::IndexedChoice(IndexedChoiceInstruction::Try(ref mut i)) [INFO] [stderr] 240 | | | &mut Line::IndexedChoice(IndexedChoiceInstruction::Retry(ref mut i)) [INFO] [stderr] 241 | | | &mut Line::IndexedChoice(IndexedChoiceInstruction::Trust(ref mut i)) => [INFO] [stderr] 242 | | *i += prelude_length - index, [INFO] [stderr] 243 | | _ => {} [INFO] [stderr] 244 | | } [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] 238 | match *line { [INFO] [stderr] 239 | Line::IndexedChoice(IndexedChoiceInstruction::Try(ref mut i)) [INFO] [stderr] 240 | | Line::IndexedChoice(IndexedChoiceInstruction::Retry(ref mut i)) [INFO] [stderr] 241 | | Line::IndexedChoice(IndexedChoiceInstruction::Trust(ref mut i)) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/write.rs:12:20 [INFO] [stderr] | [INFO] [stderr] 12 | fn error_string(e: &String) -> 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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:18:9 [INFO] [stderr] | [INFO] [stderr] 18 | / match self { [INFO] [stderr] 19 | | &IndexPtr::Module => [INFO] [stderr] 20 | | write!(f, ""), [INFO] [stderr] 21 | | &IndexPtr::Undefined => [INFO] [stderr] ... | [INFO] [stderr] 24 | | write!(f, "{}", i) [INFO] [stderr] 25 | | } [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] 18 | match *self { [INFO] [stderr] 19 | IndexPtr::Module => [INFO] [stderr] 20 | write!(f, ""), [INFO] [stderr] 21 | IndexPtr::Undefined => [INFO] [stderr] 22 | write!(f, "undefined"), [INFO] [stderr] 23 | IndexPtr::Index(i) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:37:9 [INFO] [stderr] | [INFO] [stderr] 37 | / match self { [INFO] [stderr] 38 | | &FactInstruction::GetConstant(lvl, ref constant, ref r) => [INFO] [stderr] 39 | | write!(f, "get_constant {}, {}{}", constant, lvl, r.reg_num()), [INFO] [stderr] 40 | | &FactInstruction::GetList(lvl, ref r) => [INFO] [stderr] ... | [INFO] [stderr] 57 | | write!(f, "unify_void {}", n) [INFO] [stderr] 58 | | } [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] 37 | match *self { [INFO] [stderr] 38 | FactInstruction::GetConstant(lvl, ref constant, ref r) => [INFO] [stderr] 39 | write!(f, "get_constant {}, {}{}", constant, lvl, r.reg_num()), [INFO] [stderr] 40 | FactInstruction::GetList(lvl, ref r) => [INFO] [stderr] 41 | write!(f, "get_list {}{}", lvl, r.reg_num()), [INFO] [stderr] 42 | FactInstruction::GetStructure(ref ct, ref arity, ref r) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:64:9 [INFO] [stderr] | [INFO] [stderr] 64 | / match self { [INFO] [stderr] 65 | | &QueryInstruction::GetVariable(ref x, ref a) => [INFO] [stderr] 66 | | write!(f, "query:get_variable {}, A{}", x, a), [INFO] [stderr] 67 | | &QueryInstruction::PutConstant(lvl, ref constant, ref r) => [INFO] [stderr] ... | [INFO] [stderr] 88 | | write!(f, "set_void {}", n) [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] 64 | match *self { [INFO] [stderr] 65 | QueryInstruction::GetVariable(ref x, ref a) => [INFO] [stderr] 66 | write!(f, "query:get_variable {}, A{}", x, a), [INFO] [stderr] 67 | QueryInstruction::PutConstant(lvl, ref constant, ref r) => [INFO] [stderr] 68 | write!(f, "put_constant {}, {}{}", constant, lvl, r.reg_num()), [INFO] [stderr] 69 | QueryInstruction::PutList(lvl, ref r) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:95:9 [INFO] [stderr] | [INFO] [stderr] 95 | / match self { [INFO] [stderr] 96 | | &CompareNumberQT::GreaterThan => write!(f, ">"), [INFO] [stderr] 97 | | &CompareNumberQT::GreaterThanOrEqual => write!(f, ">="), [INFO] [stderr] 98 | | &CompareNumberQT::LessThan => write!(f, "<"), [INFO] [stderr] ... | [INFO] [stderr] 101 | | &CompareNumberQT::Equal => write!(f, "=:="), [INFO] [stderr] 102 | | } [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] 95 | match *self { [INFO] [stderr] 96 | CompareNumberQT::GreaterThan => write!(f, ">"), [INFO] [stderr] 97 | CompareNumberQT::GreaterThanOrEqual => write!(f, ">="), [INFO] [stderr] 98 | CompareNumberQT::LessThan => write!(f, "<"), [INFO] [stderr] 99 | CompareNumberQT::LessThanOrEqual => write!(f, "<="), [INFO] [stderr] 100 | CompareNumberQT::NotEqual => write!(f, "=\\="), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:108:9 [INFO] [stderr] | [INFO] [stderr] 108 | / match self { [INFO] [stderr] 109 | | &CompareTermQT::GreaterThan => write!(f, "@>"), [INFO] [stderr] 110 | | &CompareTermQT::GreaterThanOrEqual => write!(f, "@>="), [INFO] [stderr] 111 | | &CompareTermQT::LessThan => write!(f, "@<"), [INFO] [stderr] ... | [INFO] [stderr] 114 | | &CompareTermQT::Equal => write!(f, "=@="), [INFO] [stderr] 115 | | } [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] 108 | match *self { [INFO] [stderr] 109 | CompareTermQT::GreaterThan => write!(f, "@>"), [INFO] [stderr] 110 | CompareTermQT::GreaterThanOrEqual => write!(f, "@>="), [INFO] [stderr] 111 | CompareTermQT::LessThan => write!(f, "@<"), [INFO] [stderr] 112 | CompareTermQT::LessThanOrEqual => write!(f, "@<="), [INFO] [stderr] 113 | CompareTermQT::NotEqual => write!(f, "\\=@="), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:133:9 [INFO] [stderr] | [INFO] [stderr] 133 | / match self { [INFO] [stderr] 134 | | &ControlInstruction::Allocate(num_cells) => [INFO] [stderr] 135 | | write!(f, "allocate {}", num_cells), [INFO] [stderr] 136 | | &ControlInstruction::CallClause(ref ct, arity, pvs, true, true) => [INFO] [stderr] ... | [INFO] [stderr] 151 | | write!(f, "proceed"), [INFO] [stderr] 152 | | } [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] 133 | match *self { [INFO] [stderr] 134 | ControlInstruction::Allocate(num_cells) => [INFO] [stderr] 135 | write!(f, "allocate {}", num_cells), [INFO] [stderr] 136 | ControlInstruction::CallClause(ref ct, arity, pvs, true, true) => [INFO] [stderr] 137 | write!(f, "call_with_default_policy {}/{}, {}", ct, arity, pvs), [INFO] [stderr] 138 | ControlInstruction::CallClause(ref ct, arity, pvs, false, true) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:158:9 [INFO] [stderr] | [INFO] [stderr] 158 | / match self { [INFO] [stderr] 159 | | &IndexedChoiceInstruction::Try(offset) => [INFO] [stderr] 160 | | write!(f, "try {}", offset), [INFO] [stderr] 161 | | &IndexedChoiceInstruction::Retry(offset) => [INFO] [stderr] ... | [INFO] [stderr] 164 | | write!(f, "trust {}", offset) [INFO] [stderr] 165 | | } [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] 158 | match *self { [INFO] [stderr] 159 | IndexedChoiceInstruction::Try(offset) => [INFO] [stderr] 160 | write!(f, "try {}", offset), [INFO] [stderr] 161 | IndexedChoiceInstruction::Retry(offset) => [INFO] [stderr] 162 | write!(f, "retry {}", offset), [INFO] [stderr] 163 | IndexedChoiceInstruction::Trust(offset) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:171:9 [INFO] [stderr] | [INFO] [stderr] 171 | / match self { [INFO] [stderr] 172 | | &ChoiceInstruction::TryMeElse(offset) => [INFO] [stderr] 173 | | write!(f, "try_me_else {}", offset), [INFO] [stderr] 174 | | &ChoiceInstruction::DefaultRetryMeElse(offset) => [INFO] [stderr] ... | [INFO] [stderr] 181 | | write!(f, "trust_me") [INFO] [stderr] 182 | | } [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] 171 | match *self { [INFO] [stderr] 172 | ChoiceInstruction::TryMeElse(offset) => [INFO] [stderr] 173 | write!(f, "try_me_else {}", offset), [INFO] [stderr] 174 | ChoiceInstruction::DefaultRetryMeElse(offset) => [INFO] [stderr] 175 | write!(f, "retry_me_else_by_default {}", offset), [INFO] [stderr] 176 | ChoiceInstruction::RetryMeElse(offset) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:188:9 [INFO] [stderr] | [INFO] [stderr] 188 | / match self { [INFO] [stderr] 189 | | &IndexingInstruction::SwitchOnTerm(v, c, l, s) => [INFO] [stderr] 190 | | write!(f, "switch_on_term {}, {}, {}, {}", v, c, l, s), [INFO] [stderr] 191 | | &IndexingInstruction::SwitchOnConstant(num_cs, _) => [INFO] [stderr] ... | [INFO] [stderr] 194 | | write!(f, "switch_on_structure {}", num_ss) [INFO] [stderr] 195 | | } [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] 188 | match *self { [INFO] [stderr] 189 | IndexingInstruction::SwitchOnTerm(v, c, l, s) => [INFO] [stderr] 190 | write!(f, "switch_on_term {}, {}, {}, {}", v, c, l, s), [INFO] [stderr] 191 | IndexingInstruction::SwitchOnConstant(num_cs, _) => [INFO] [stderr] 192 | write!(f, "switch_on_constant {}", num_cs), [INFO] [stderr] 193 | IndexingInstruction::SwitchOnStructure(num_ss, _) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:201:9 [INFO] [stderr] | [INFO] [stderr] 201 | / match self { [INFO] [stderr] 202 | | &SessionError::CannotOverwriteBuiltIn(ref msg) => [INFO] [stderr] 203 | | write!(f, "cannot overwrite {}", msg), [INFO] [stderr] 204 | | &SessionError::CannotOverwriteImport(ref msg) => [INFO] [stderr] ... | [INFO] [stderr] 214 | | &SessionError::UserPrompt => write!(f, "enter predicate at [user] prompt") [INFO] [stderr] 215 | | } [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] 201 | match *self { [INFO] [stderr] 202 | SessionError::CannotOverwriteBuiltIn(ref msg) => [INFO] [stderr] 203 | write!(f, "cannot overwrite {}", msg), [INFO] [stderr] 204 | SessionError::CannotOverwriteImport(ref msg) => [INFO] [stderr] 205 | write!(f, "cannot overwrite import {}", msg), [INFO] [stderr] 206 | SessionError::ModuleNotFound => write!(f, "module not found."), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:221:9 [INFO] [stderr] | [INFO] [stderr] 221 | / match self { [INFO] [stderr] 222 | | &ArithmeticTerm::Reg(r) => write!(f, "{}", r), [INFO] [stderr] 223 | | &ArithmeticTerm::Interm(i) => write!(f, "@{}", i), [INFO] [stderr] 224 | | &ArithmeticTerm::Number(ref n) => write!(f, "{}", n), [INFO] [stderr] 225 | | } [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] 221 | match *self { [INFO] [stderr] 222 | ArithmeticTerm::Reg(r) => write!(f, "{}", r), [INFO] [stderr] 223 | ArithmeticTerm::Interm(i) => write!(f, "@{}", i), [INFO] [stderr] 224 | ArithmeticTerm::Number(ref n) => write!(f, "{}", n), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:231:9 [INFO] [stderr] | [INFO] [stderr] 231 | / match self { [INFO] [stderr] 232 | | &ArithmeticInstruction::Abs(ref a1, ref t) => [INFO] [stderr] 233 | | write!(f, "abs {}, @{}", a1, t), [INFO] [stderr] 234 | | &ArithmeticInstruction::Add(ref a1, ref a2, ref t) => [INFO] [stderr] ... | [INFO] [stderr] 265 | | write!(f, "neg {}, @{}", a, t) [INFO] [stderr] 266 | | } [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] 231 | match *self { [INFO] [stderr] 232 | ArithmeticInstruction::Abs(ref a1, ref t) => [INFO] [stderr] 233 | write!(f, "abs {}, @{}", a1, t), [INFO] [stderr] 234 | ArithmeticInstruction::Add(ref a1, ref a2, ref t) => [INFO] [stderr] 235 | write!(f, "add {}, {}, @{}", a1, a2, t), [INFO] [stderr] 236 | ArithmeticInstruction::Sub(ref a1, ref a2, ref t) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:272:9 [INFO] [stderr] | [INFO] [stderr] 272 | / match self { [INFO] [stderr] 273 | | &CutInstruction::Cut(r) => [INFO] [stderr] 274 | | write!(f, "cut {}", r), [INFO] [stderr] 275 | | &CutInstruction::NeckCut => [INFO] [stderr] ... | [INFO] [stderr] 280 | | write!(f, "get_level_and_unify {}", r) [INFO] [stderr] 281 | | } [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] 272 | match *self { [INFO] [stderr] 273 | CutInstruction::Cut(r) => [INFO] [stderr] 274 | write!(f, "cut {}", r), [INFO] [stderr] 275 | CutInstruction::NeckCut => [INFO] [stderr] 276 | write!(f, "neck_cut"), [INFO] [stderr] 277 | CutInstruction::GetLevel(r) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:287:9 [INFO] [stderr] | [INFO] [stderr] 287 | / match self { [INFO] [stderr] 288 | | &Level::Root | &Level::Shallow => write!(f, "A"), [INFO] [stderr] 289 | | &Level::Deep => write!(f, "X") [INFO] [stderr] 290 | | } [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] 287 | match *self { [INFO] [stderr] 288 | Level::Root | Level::Shallow => write!(f, "A"), [INFO] [stderr] 289 | Level::Deep => write!(f, "X") [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/write.rs:336:21 [INFO] [stderr] | [INFO] [stderr] 336 | / if let &EvalSession::Error(SessionError::QueryFailure) = &result [INFO] [stderr] 337 | | { [INFO] [stderr] 338 | | write!(stdout, "false.\n\r").unwrap(); [INFO] [stderr] 339 | | stdout.flush().unwrap(); [INFO] [stderr] 340 | | return; [INFO] [stderr] 341 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 336 | if let EvalSession::Error(SessionError::QueryFailure) = result [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/write.rs:343:21 [INFO] [stderr] | [INFO] [stderr] 343 | / if let &EvalSession::Error(SessionError::QueryFailureWithException(ref e)) = &result [INFO] [stderr] 344 | | { [INFO] [stderr] 345 | | write!(stdout, "{}\n\r", error_string(e)).unwrap(); [INFO] [stderr] 346 | | stdout.flush().unwrap(); [INFO] [stderr] 347 | | return; [INFO] [stderr] 348 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 343 | if let EvalSession::Error(SessionError::QueryFailureWithException(ref e)) = result [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: use of `write!(stdout(), ...).unwrap()`. Consider using `print!` instead [INFO] [stderr] --> src/prolog/write.rs:354:13 [INFO] [stderr] | [INFO] [stderr] 354 | write!(stdout(), ".\n").unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::explicit_write)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_write [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/prolog/iterators.rs:40:37 [INFO] [stderr] | [INFO] [stderr] 40 | fn from_rule_head_clause(terms: &'a Vec>) -> Self { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/iterators.rs:49:21 [INFO] [stderr] | [INFO] [stderr] 49 | let state = match term { [INFO] [stderr] | _____________________^ [INFO] [stderr] 50 | | &Term::AnonVar => [INFO] [stderr] 51 | | return QueryIterator { state_stack: vec![] }, [INFO] [stderr] 52 | | &Term::Clause(ref r, ref name, ref terms, fixity) => [INFO] [stderr] ... | [INFO] [stderr] 61 | | TermIterState::Var(Level::Root, cell, (*var).clone()) [INFO] [stderr] 62 | | }; [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] 49 | let state = match *term { [INFO] [stderr] 50 | Term::AnonVar => [INFO] [stderr] 51 | return QueryIterator { state_stack: vec![] }, [INFO] [stderr] 52 | Term::Clause(ref r, ref name, ref terms, fixity) => [INFO] [stderr] 53 | TermIterState::Clause(Level::Root, 0, r, [INFO] [stderr] 54 | ClauseType::from(name.clone(), terms.len(), fixity), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/iterators.rs:68:9 [INFO] [stderr] | [INFO] [stderr] 68 | / match term { [INFO] [stderr] 69 | | &QueryTerm::Clause(ref cell, ClauseType::CallN, ref terms, _) => { [INFO] [stderr] 70 | | let state = TermIterState::Clause(Level::Root, 1, cell, ClauseType::CallN, terms); [INFO] [stderr] 71 | | QueryIterator { state_stack: vec![state] } [INFO] [stderr] ... | [INFO] [stderr] 93 | | QueryIterator { state_stack: vec![] }, [INFO] [stderr] 94 | | } [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] 68 | match *term { [INFO] [stderr] 69 | QueryTerm::Clause(ref cell, ClauseType::CallN, ref terms, _) => { [INFO] [stderr] 70 | let state = TermIterState::Clause(Level::Root, 1, cell, ClauseType::CallN, terms); [INFO] [stderr] 71 | QueryIterator { state_stack: vec![state] } [INFO] [stderr] 72 | }, [INFO] [stderr] 73 | QueryTerm::Clause(ref cell, ref ct, ref terms, _) => { [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/prolog/iterators.rs:154:41 [INFO] [stderr] | [INFO] [stderr] 154 | pub fn from_rule_head_clause(terms: &'a Vec>) -> Self { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/iterators.rs:163:22 [INFO] [stderr] | [INFO] [stderr] 163 | let states = match term { [INFO] [stderr] | ______________________^ [INFO] [stderr] 164 | | &Term::AnonVar => [INFO] [stderr] 165 | | vec![TermIterState::AnonVar(Level::Root)], [INFO] [stderr] 166 | | &Term::Clause(ref cell, ref name, ref terms, fixity) => { [INFO] [stderr] ... | [INFO] [stderr] 175 | | vec![TermIterState::Var(Level::Root, cell, var.clone())] [INFO] [stderr] 176 | | }; [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] 163 | let states = match *term { [INFO] [stderr] 164 | Term::AnonVar => [INFO] [stderr] 165 | vec![TermIterState::AnonVar(Level::Root)], [INFO] [stderr] 166 | Term::Clause(ref cell, ref name, ref terms, fixity) => { [INFO] [stderr] 167 | let ct = ClauseType::from(name.clone(), terms.len(), fixity); [INFO] [stderr] 168 | vec![TermIterState::Clause(Level::Root, 0, cell, ct, terms)] [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/prolog/iterators.rs:231:1 [INFO] [stderr] | [INFO] [stderr] 231 | / pub fn query_term_post_order_iter<'a>(query_term: &'a QueryTerm) -> QueryIterator<'a> { [INFO] [stderr] 232 | | QueryIterator::new(query_term) [INFO] [stderr] 233 | | } [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 don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/iterators.rs:237:9 [INFO] [stderr] | [INFO] [stderr] 237 | / match self { [INFO] [stderr] 238 | | &ChunkedTerm::BodyTerm(ref qt) => [INFO] [stderr] 239 | | QueryIterator::new(qt), [INFO] [stderr] 240 | | &ChunkedTerm::HeadClause(_, terms) => [INFO] [stderr] 241 | | QueryIterator::from_rule_head_clause(terms) [INFO] [stderr] 242 | | } [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] 237 | match *self { [INFO] [stderr] 238 | ChunkedTerm::BodyTerm(ref qt) => [INFO] [stderr] 239 | QueryIterator::new(qt), [INFO] [stderr] 240 | ChunkedTerm::HeadClause(_, terms) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/iterators.rs:248:9 [INFO] [stderr] | [INFO] [stderr] 248 | / if let &Term::Var(_, ref var) = term { [INFO] [stderr] 249 | | if var.as_str() == "!" { [INFO] [stderr] 250 | | return true; [INFO] [stderr] 251 | | } [INFO] [stderr] 252 | | } [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] 248 | if let Term::Var(_, ref var) = *term { [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/prolog/iterators.rs:299:55 [INFO] [stderr] | [INFO] [stderr] 299 | pub fn from_rule_body(p1: &'a QueryTerm, clauses: &'a Vec) -> Self [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[QueryTerm]` [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: this function has too many arguments (10/7) [INFO] [stderr] --> src/prolog/or_stack.rs:20:5 [INFO] [stderr] | [INFO] [stderr] 20 | / fn new(global_index: usize, [INFO] [stderr] 21 | | e: usize, [INFO] [stderr] 22 | | cp: LocalCodePtr, [INFO] [stderr] 23 | | b: usize, [INFO] [stderr] ... | [INFO] [stderr] 43 | | } [INFO] [stderr] 44 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stderr] [INFO] [stderr] warning: this function has too many arguments (11/7) [INFO] [stderr] --> src/prolog/or_stack.rs:58:5 [INFO] [stderr] | [INFO] [stderr] 58 | / pub fn push(&mut self, [INFO] [stderr] 59 | | global_index: usize, [INFO] [stderr] 60 | | e: usize, [INFO] [stderr] 61 | | cp: LocalCodePtr, [INFO] [stderr] ... | [INFO] [stderr] 70 | | self.0.push(Frame::new(global_index, e, cp, b, bp, tr, pstr_tr, h, b0, n)); [INFO] [stderr] 71 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> src/prolog/heap_print.rs:68:12 [INFO] [stderr] | [INFO] [stderr] 68 | if self.contents.len() != 0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!self.contents.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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/heap_print.rs:92:19 [INFO] [stderr] | [INFO] [stderr] 92 | arity == 1 && if let &ClauseType::Named(ref name, _) = ct { [INFO] [stderr] | ___________________^ [INFO] [stderr] 93 | | name.as_str() == "$VAR" [INFO] [stderr] 94 | | } else { [INFO] [stderr] 95 | | false [INFO] [stderr] 96 | | } [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] 92 | arity == 1 && if let ClauseType::Named(ref name, _) = *ct { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ [INFO] [stderr] [INFO] [stderr] error: this `if` has identical blocks [INFO] [stderr] --> src/prolog/heap_print.rs:160:48 [INFO] [stderr] | [INFO] [stderr] 160 | } else if capital_letter_char!(ac) { [INFO] [stderr] | ________________________________________________^ [INFO] [stderr] 161 | | alpha_numeric_char!(oc) [INFO] [stderr] 162 | | } else { [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] note: same as this [INFO] [stderr] --> src/prolog/heap_print.rs:158:52 [INFO] [stderr] | [INFO] [stderr] 158 | } else if variable_indicator_char!(ac) { [INFO] [stderr] | ____________________________________________________^ [INFO] [stderr] 159 | | alpha_numeric_char!(oc) [INFO] [stderr] 160 | | } else if capital_letter_char!(ac) { [INFO] [stderr] | |_____________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 39 [INFO] [stderr] --> src/prolog/heap_print.rs:178:1 [INFO] [stderr] | [INFO] [stderr] 178 | / fn non_quoted_graphic_token>(mut iter: Iter, c: char) -> bool { [INFO] [stderr] 179 | | if c == '/' { [INFO] [stderr] 180 | | return match iter.next() { [INFO] [stderr] 181 | | None => true, [INFO] [stderr] ... | [INFO] [stderr] 200 | | } [INFO] [stderr] 201 | | } [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: this boolean expression can be simplified [INFO] [stderr] --> src/prolog/heap_print.rs:214:13 [INFO] [stderr] | [INFO] [stderr] 214 | !iter.next().is_none() [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^ help: try: `iter.next().is_some()` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::nonminimal_bool)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stderr] [INFO] [stderr] error: this `if` has identical blocks [INFO] [stderr] --> src/prolog/heap_print.rs:211:32 [INFO] [stderr] | [INFO] [stderr] 211 | } else if cut_char!(c) { [INFO] [stderr] | ________________________________^ [INFO] [stderr] 212 | | iter.next().is_none() [INFO] [stderr] 213 | | } else if solo_char!(c) { [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] note: same as this [INFO] [stderr] --> src/prolog/heap_print.rs:209:38 [INFO] [stderr] | [INFO] [stderr] 209 | } else if semicolon_char!(c) { [INFO] [stderr] | ______________________________________^ [INFO] [stderr] 210 | | iter.next().is_none() [INFO] [stderr] 211 | | } else if cut_char!(c) { [INFO] [stderr] | |_________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/heap_print.rs:231:5 [INFO] [stderr] | [INFO] [stderr] 231 | / match op { [INFO] [stderr] 232 | | &Some(DirectedOp::Left(ref lop)) if continues_with_append(lop.as_str(), atom) => [INFO] [stderr] 233 | | Some(DirectedOp::Left(lop.clone())), [INFO] [stderr] 234 | | &Some(DirectedOp::Right(ref rop)) if continues_with_append(atom, rop.as_str()) => [INFO] [stderr] ... | [INFO] [stderr] 237 | | None [INFO] [stderr] 238 | | } [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] 231 | match *op { [INFO] [stderr] 232 | Some(DirectedOp::Left(ref lop)) if continues_with_append(lop.as_str(), atom) => [INFO] [stderr] 233 | Some(DirectedOp::Left(lop.clone())), [INFO] [stderr] 234 | Some(DirectedOp::Right(ref rop)) if continues_with_append(atom, rop.as_str()) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: needlessly taken reference of both operands [INFO] [stderr] --> src/prolog/heap_print.rs:446:20 [INFO] [stderr] | [INFO] [stderr] 446 | if &fl == &OrderedFloat(0f64) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#op_ref [INFO] [stderr] help: use the values directly [INFO] [stderr] | [INFO] [stderr] 446 | if fl == OrderedFloat(0f64) { [INFO] [stderr] | ^^ ^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/targets.rs:58:9 [INFO] [stderr] | [INFO] [stderr] 58 | / match self { [INFO] [stderr] 59 | | &FactInstruction::UnifyVoid(_) => true, [INFO] [stderr] 60 | | _ => false [INFO] [stderr] 61 | | } [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] 58 | match *self { [INFO] [stderr] 59 | FactInstruction::UnifyVoid(_) => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/targets.rs:65:9 [INFO] [stderr] | [INFO] [stderr] 65 | / match self { [INFO] [stderr] 66 | | &mut FactInstruction::UnifyVoid(ref mut incr) => *incr += 1, [INFO] [stderr] 67 | | _ => {} [INFO] [stderr] 68 | | } [INFO] [stderr] | |_________^ help: try this: `if let &mut FactInstruction::UnifyVoid(ref mut incr) = self { *incr += 1 }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/targets.rs:65:9 [INFO] [stderr] | [INFO] [stderr] 65 | / match self { [INFO] [stderr] 66 | | &mut FactInstruction::UnifyVoid(ref mut incr) => *incr += 1, [INFO] [stderr] 67 | | _ => {} [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] 65 | match *self { [INFO] [stderr] 66 | FactInstruction::UnifyVoid(ref mut incr) => *incr += 1, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/targets.rs:125:9 [INFO] [stderr] | [INFO] [stderr] 125 | / match self { [INFO] [stderr] 126 | | &QueryInstruction::SetVoid(_) => true, [INFO] [stderr] 127 | | _ => false [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] 125 | match *self { [INFO] [stderr] 126 | QueryInstruction::SetVoid(_) => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/targets.rs:132:9 [INFO] [stderr] | [INFO] [stderr] 132 | / match self { [INFO] [stderr] 133 | | &mut QueryInstruction::SetVoid(ref mut incr) => *incr += 1, [INFO] [stderr] 134 | | _ => {} [INFO] [stderr] 135 | | } [INFO] [stderr] | |_________^ help: try this: `if let &mut QueryInstruction::SetVoid(ref mut incr) = self { *incr += 1 }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/targets.rs:132:9 [INFO] [stderr] | [INFO] [stderr] 132 | / match self { [INFO] [stderr] 133 | | &mut QueryInstruction::SetVoid(ref mut incr) => *incr += 1, [INFO] [stderr] 134 | | _ => {} [INFO] [stderr] 135 | | } [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] 132 | match *self { [INFO] [stderr] 133 | QueryInstruction::SetVoid(ref mut incr) => *incr += 1, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/read.rs:18:9 [INFO] [stderr] | [INFO] [stderr] 18 | / match self { [INFO] [stderr] 19 | | &TermRef::AnonVar(_) | &TermRef::Var(..) => Addr::HeapCell(h), [INFO] [stderr] 20 | | &TermRef::Cons(..) => Addr::HeapCell(h), [INFO] [stderr] 21 | | &TermRef::Constant(_, _, c) => Addr::Con(c.clone()), [INFO] [stderr] 22 | | &TermRef::Clause(..) => Addr::Str(h), [INFO] [stderr] 23 | | } [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] 18 | match *self { [INFO] [stderr] 19 | TermRef::AnonVar(_) | TermRef::Var(..) => Addr::HeapCell(h), [INFO] [stderr] 20 | TermRef::Cons(..) => Addr::HeapCell(h), [INFO] [stderr] 21 | TermRef::Constant(_, _, c) => Addr::Con(c.clone()), [INFO] [stderr] 22 | TermRef::Clause(..) => Addr::Str(h), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/read.rs:94:9 [INFO] [stderr] | [INFO] [stderr] 94 | / match &term { [INFO] [stderr] 95 | | &TermRef::Cons(lvl, ..) => { [INFO] [stderr] 96 | | queue.push_back((2, h+1)); [INFO] [stderr] 97 | | machine_st.heap.push(HeapCellValue::Addr(Addr::Lis(h+1))); [INFO] [stderr] ... | [INFO] [stderr] 148 | | _ => {} [INFO] [stderr] 149 | | }; [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: try [INFO] [stderr] | [INFO] [stderr] 94 | match term { [INFO] [stderr] 95 | TermRef::Cons(lvl, ..) => { [INFO] [stderr] 96 | queue.push_back((2, h+1)); [INFO] [stderr] 97 | machine_st.heap.push(HeapCellValue::Addr(Addr::Lis(h+1))); [INFO] [stderr] 98 | [INFO] [stderr] 99 | push_stub_addr(machine_st); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] error: aborting due to 3 previous errors [INFO] [stderr] [INFO] [stderr] error: Could not compile `rusty-wam`. [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:28:9 [INFO] [stderr] | [INFO] [stderr] 28 | / match self { [INFO] [stderr] 29 | | &InlinedClauseType::CompareNumber(qt, ..) => qt.name(), [INFO] [stderr] 30 | | &InlinedClauseType::IsAtom(..) => "atom", [INFO] [stderr] 31 | | &InlinedClauseType::IsAtomic(..) => "atomic", [INFO] [stderr] ... | [INFO] [stderr] 39 | | &InlinedClauseType::IsVar(..) => "var", [INFO] [stderr] 40 | | } [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] 28 | match *self { [INFO] [stderr] 29 | InlinedClauseType::CompareNumber(qt, ..) => qt.name(), [INFO] [stderr] 30 | InlinedClauseType::IsAtom(..) => "atom", [INFO] [stderr] 31 | InlinedClauseType::IsAtomic(..) => "atomic", [INFO] [stderr] 32 | InlinedClauseType::IsCompound(..) => "compound", [INFO] [stderr] 33 | InlinedClauseType::IsInteger (..) => "integer", [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:139:9 [INFO] [stderr] | [INFO] [stderr] 139 | / match self { [INFO] [stderr] 140 | | &mut QueryTerm::Clause(_, _, _, ref mut use_default_cp) => *use_default_cp = true, [INFO] [stderr] 141 | | _ => {} [INFO] [stderr] 142 | | }; [INFO] [stderr] | |_________^ help: try this: `if let &mut QueryTerm::Clause(_, _, _, ref mut use_default_cp) = self { *use_default_cp = true }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:139:9 [INFO] [stderr] | [INFO] [stderr] 139 | / match self { [INFO] [stderr] 140 | | &mut QueryTerm::Clause(_, _, _, ref mut use_default_cp) => *use_default_cp = true, [INFO] [stderr] 141 | | _ => {} [INFO] [stderr] 142 | | }; [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] 139 | match *self { [INFO] [stderr] 140 | QueryTerm::Clause(_, _, _, ref mut use_default_cp) => *use_default_cp = true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:146:9 [INFO] [stderr] | [INFO] [stderr] 146 | / match self { [INFO] [stderr] 147 | | &QueryTerm::Clause(_, _, ref subterms, ..) => subterms.len(), [INFO] [stderr] 148 | | &QueryTerm::BlockedCut | &QueryTerm::UnblockedCut(..) => 0, [INFO] [stderr] 149 | | &QueryTerm::Jump(ref vars) => vars.len(), [INFO] [stderr] 150 | | &QueryTerm::GetLevelAndUnify(..) => 1, [INFO] [stderr] 151 | | } [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] 146 | match *self { [INFO] [stderr] 147 | QueryTerm::Clause(_, _, ref subterms, ..) => subterms.len(), [INFO] [stderr] 148 | QueryTerm::BlockedCut | QueryTerm::UnblockedCut(..) => 0, [INFO] [stderr] 149 | QueryTerm::Jump(ref vars) => vars.len(), [INFO] [stderr] 150 | QueryTerm::GetLevelAndUnify(..) => 1, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:175:9 [INFO] [stderr] | [INFO] [stderr] 175 | / match self { [INFO] [stderr] 176 | | &PredicateClause::Fact(ref term) => term.first_arg(), [INFO] [stderr] 177 | | &PredicateClause::Rule(ref rule) => rule.head.1.first().map(|bt| bt.as_ref()), [INFO] [stderr] 178 | | } [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] 175 | match *self { [INFO] [stderr] 176 | PredicateClause::Fact(ref term) => term.first_arg(), [INFO] [stderr] 177 | PredicateClause::Rule(ref rule) => rule.head.1.first().map(|bt| bt.as_ref()), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:182:9 [INFO] [stderr] | [INFO] [stderr] 182 | / match self { [INFO] [stderr] 183 | | &PredicateClause::Fact(ref term) => term.arity(), [INFO] [stderr] 184 | | &PredicateClause::Rule(ref rule) => rule.head.1.len() [INFO] [stderr] 185 | | } [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] 182 | match *self { [INFO] [stderr] 183 | PredicateClause::Fact(ref term) => term.arity(), [INFO] [stderr] 184 | PredicateClause::Rule(ref rule) => rule.head.1.len() [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:189:9 [INFO] [stderr] | [INFO] [stderr] 189 | / match self { [INFO] [stderr] 190 | | &PredicateClause::Fact(ref term) => term.name(), [INFO] [stderr] 191 | | &PredicateClause::Rule(ref rule) => Some(rule.head.0.clone()), [INFO] [stderr] 192 | | } [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] 189 | match *self { [INFO] [stderr] 190 | PredicateClause::Fact(ref term) => term.name(), [INFO] [stderr] 191 | PredicateClause::Rule(ref rule) => Some(rule.head.0.clone()), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:257:9 [INFO] [stderr] | [INFO] [stderr] 257 | / match self { [INFO] [stderr] 258 | | &SystemClauseType::CheckCutPoint => clause_name!("$check_cp"), [INFO] [stderr] 259 | | &SystemClauseType::ExpandTerm => clause_name!("$expand_term"), [INFO] [stderr] 260 | | &SystemClauseType::ExpandGoal => clause_name!("$expand_goal"), [INFO] [stderr] ... | [INFO] [stderr] 289 | | &SystemClauseType::WriteTerm => clause_name!("$write_term"), [INFO] [stderr] 290 | | } [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] 257 | match *self { [INFO] [stderr] 258 | SystemClauseType::CheckCutPoint => clause_name!("$check_cp"), [INFO] [stderr] 259 | SystemClauseType::ExpandTerm => clause_name!("$expand_term"), [INFO] [stderr] 260 | SystemClauseType::ExpandGoal => clause_name!("$expand_goal"), [INFO] [stderr] 261 | SystemClauseType::GetBValue => clause_name!("$get_b_value"), [INFO] [stderr] 262 | SystemClauseType::GetDoubleQuotes => clause_name!("$get_double_quotes"), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:386:9 [INFO] [stderr] | [INFO] [stderr] 386 | / match self { [INFO] [stderr] 387 | | &BuiltInClauseType::Compare | &BuiltInClauseType::CompareTerm(_) [INFO] [stderr] 388 | | | &BuiltInClauseType::NotEq | &BuiltInClauseType::Is(..) | &BuiltInClauseType::Eq [INFO] [stderr] 389 | | => Some(Fixity::In), [INFO] [stderr] 390 | | _ => None [INFO] [stderr] 391 | | } [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] 386 | match *self { [INFO] [stderr] 387 | BuiltInClauseType::Compare | BuiltInClauseType::CompareTerm(_) [INFO] [stderr] 388 | | BuiltInClauseType::NotEq | BuiltInClauseType::Is(..) | BuiltInClauseType::Eq [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:395:9 [INFO] [stderr] | [INFO] [stderr] 395 | / match self { [INFO] [stderr] 396 | | &BuiltInClauseType::AcyclicTerm => clause_name!("acyclic_term"), [INFO] [stderr] 397 | | &BuiltInClauseType::Arg => clause_name!("arg"), [INFO] [stderr] 398 | | &BuiltInClauseType::Compare => clause_name!("compare"), [INFO] [stderr] ... | [INFO] [stderr] 410 | | &BuiltInClauseType::PartialString => clause_name!("partial_string") [INFO] [stderr] 411 | | } [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] 395 | match *self { [INFO] [stderr] 396 | BuiltInClauseType::AcyclicTerm => clause_name!("acyclic_term"), [INFO] [stderr] 397 | BuiltInClauseType::Arg => clause_name!("arg"), [INFO] [stderr] 398 | BuiltInClauseType::Compare => clause_name!("compare"), [INFO] [stderr] 399 | BuiltInClauseType::CompareTerm(qt) => clause_name!(qt.name()), [INFO] [stderr] 400 | BuiltInClauseType::CyclicTerm => clause_name!("cyclic_term"), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:415:9 [INFO] [stderr] | [INFO] [stderr] 415 | / match self { [INFO] [stderr] 416 | | &BuiltInClauseType::AcyclicTerm => 1, [INFO] [stderr] 417 | | &BuiltInClauseType::Arg => 3, [INFO] [stderr] 418 | | &BuiltInClauseType::Compare => 2, [INFO] [stderr] ... | [INFO] [stderr] 430 | | &BuiltInClauseType::PartialString => 1, [INFO] [stderr] 431 | | } [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] 415 | match *self { [INFO] [stderr] 416 | BuiltInClauseType::AcyclicTerm => 1, [INFO] [stderr] 417 | BuiltInClauseType::Arg => 3, [INFO] [stderr] 418 | BuiltInClauseType::Compare => 2, [INFO] [stderr] 419 | BuiltInClauseType::CompareTerm(_) => 2, [INFO] [stderr] 420 | BuiltInClauseType::CyclicTerm => 1, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:463:9 [INFO] [stderr] | [INFO] [stderr] 463 | / match self { [INFO] [stderr] 464 | | &ClauseType::BuiltIn(ref built_in) => built_in.fixity(), [INFO] [stderr] 465 | | &ClauseType::Inlined(InlinedClauseType::CompareNumber(..)) => Some(Fixity::In), [INFO] [stderr] 466 | | &ClauseType::Op(_, fixity, _) => Some(fixity), [INFO] [stderr] 467 | | &ClauseType::System(ref system) => system.fixity(), [INFO] [stderr] 468 | | _ => None [INFO] [stderr] 469 | | } [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] 463 | match *self { [INFO] [stderr] 464 | ClauseType::BuiltIn(ref built_in) => built_in.fixity(), [INFO] [stderr] 465 | ClauseType::Inlined(InlinedClauseType::CompareNumber(..)) => Some(Fixity::In), [INFO] [stderr] 466 | ClauseType::Op(_, fixity, _) => Some(fixity), [INFO] [stderr] 467 | ClauseType::System(ref system) => system.fixity(), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:473:9 [INFO] [stderr] | [INFO] [stderr] 473 | / match self { [INFO] [stderr] 474 | | &ClauseType::CallN => clause_name!("call"), [INFO] [stderr] 475 | | &ClauseType::BuiltIn(ref built_in) => built_in.name(), [INFO] [stderr] 476 | | &ClauseType::Hook(ref hook) => hook.name(), [INFO] [stderr] ... | [INFO] [stderr] 480 | | &ClauseType::System(ref system) => system.name(), [INFO] [stderr] 481 | | } [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] 473 | match *self { [INFO] [stderr] 474 | ClauseType::CallN => clause_name!("call"), [INFO] [stderr] 475 | ClauseType::BuiltIn(ref built_in) => built_in.name(), [INFO] [stderr] 476 | ClauseType::Hook(ref hook) => hook.name(), [INFO] [stderr] 477 | ClauseType::Inlined(ref inlined) => clause_name!(inlined.name()), [INFO] [stderr] 478 | ClauseType::Op(ref name, ..) => name.clone(), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:542:9 [INFO] [stderr] | [INFO] [stderr] 542 | / match self { [INFO] [stderr] 543 | | &IndexedChoiceInstruction::Retry(offset) => offset, [INFO] [stderr] 544 | | &IndexedChoiceInstruction::Trust(offset) => offset, [INFO] [stderr] 545 | | &IndexedChoiceInstruction::Try(offset) => offset [INFO] [stderr] 546 | | } [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] 542 | match *self { [INFO] [stderr] 543 | IndexedChoiceInstruction::Retry(offset) => offset, [INFO] [stderr] 544 | IndexedChoiceInstruction::Trust(offset) => offset, [INFO] [stderr] 545 | IndexedChoiceInstruction::Try(offset) => offset [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:558:9 [INFO] [stderr] | [INFO] [stderr] 558 | / if let &ArithmeticTerm::Interm(interm) = self { [INFO] [stderr] 559 | | interm [INFO] [stderr] 560 | | } else { [INFO] [stderr] 561 | | interm [INFO] [stderr] 562 | | } [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] 558 | if let ArithmeticTerm::Interm(interm) = *self { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:598:9 [INFO] [stderr] | [INFO] [stderr] 598 | / match self { [INFO] [stderr] 599 | | &ControlInstruction::CallClause(..) => true, [INFO] [stderr] 600 | | &ControlInstruction::JmpBy(..) => true, [INFO] [stderr] 601 | | _ => false [INFO] [stderr] 602 | | } [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] 598 | match *self { [INFO] [stderr] 599 | ControlInstruction::CallClause(..) => true, [INFO] [stderr] 600 | ControlInstruction::JmpBy(..) => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:680:9 [INFO] [stderr] | [INFO] [stderr] 680 | / match self { [INFO] [stderr] 681 | | &Addr::Con(ref c) => write!(f, "Addr::Con({})", c), [INFO] [stderr] 682 | | &Addr::Lis(l) => write!(f, "Addr::Lis({})", l), [INFO] [stderr] 683 | | &Addr::HeapCell(h) => write!(f, "Addr::HeapCell({})", h), [INFO] [stderr] 684 | | &Addr::StackCell(fr, sc)=> write!(f, "Addr::StackCell({}, {})", fr, sc), [INFO] [stderr] 685 | | &Addr::Str(s) => write!(f, "Addr::Str({})", s) [INFO] [stderr] 686 | | } [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] 680 | match *self { [INFO] [stderr] 681 | Addr::Con(ref c) => write!(f, "Addr::Con({})", c), [INFO] [stderr] 682 | Addr::Lis(l) => write!(f, "Addr::Lis({})", l), [INFO] [stderr] 683 | Addr::HeapCell(h) => write!(f, "Addr::HeapCell({})", h), [INFO] [stderr] 684 | Addr::StackCell(fr, sc)=> write!(f, "Addr::StackCell({}, {})", fr, sc), [INFO] [stderr] 685 | Addr::Str(s) => write!(f, "Addr::Str({})", s) [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:699:9 [INFO] [stderr] | [INFO] [stderr] 699 | / match self { [INFO] [stderr] 700 | | &Addr::StackCell(fr, sc) => [INFO] [stderr] 701 | | match *r { [INFO] [stderr] 702 | | Ref::HeapCell(_) => Some(Ordering::Greater), [INFO] [stderr] ... | [INFO] [stderr] 717 | | _ => None [INFO] [stderr] 718 | | } [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] 699 | match *self { [INFO] [stderr] 700 | Addr::StackCell(fr, sc) => [INFO] [stderr] 701 | match *r { [INFO] [stderr] 702 | Ref::HeapCell(_) => Some(Ordering::Greater), [INFO] [stderr] 703 | Ref::StackCell(fr1, sc1) => [INFO] [stderr] 704 | if fr1 < fr || (fr1 == fr && sc1 < sc) { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:713:17 [INFO] [stderr] | [INFO] [stderr] 713 | / match r { [INFO] [stderr] 714 | | &Ref::StackCell(..) => Some(Ordering::Less), [INFO] [stderr] 715 | | &Ref::HeapCell(h1) => h.partial_cmp(&h1) [INFO] [stderr] 716 | | }, [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] 713 | match *r { [INFO] [stderr] 714 | Ref::StackCell(..) => Some(Ordering::Less), [INFO] [stderr] 715 | Ref::HeapCell(h1) => h.partial_cmp(&h1) [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:724:9 [INFO] [stderr] | [INFO] [stderr] 724 | / match self { [INFO] [stderr] 725 | | &Addr::HeapCell(_) | &Addr::StackCell(_, _) => true, [INFO] [stderr] 726 | | _ => false [INFO] [stderr] 727 | | } [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] 724 | match *self { [INFO] [stderr] 725 | Addr::HeapCell(_) | Addr::StackCell(_, _) => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:731:9 [INFO] [stderr] | [INFO] [stderr] 731 | / match self { [INFO] [stderr] 732 | | &Addr::HeapCell(hc) => Some(Ref::HeapCell(hc)), [INFO] [stderr] 733 | | &Addr::StackCell(fr, sc) => Some(Ref::StackCell(fr, sc)), [INFO] [stderr] 734 | | _ => None [INFO] [stderr] 735 | | } [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] 731 | match *self { [INFO] [stderr] 732 | Addr::HeapCell(hc) => Some(Ref::HeapCell(hc)), [INFO] [stderr] 733 | Addr::StackCell(fr, sc) => Some(Ref::StackCell(fr, sc)), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:739:9 [INFO] [stderr] | [INFO] [stderr] 739 | / match self { [INFO] [stderr] 740 | | &Addr::StackCell(addr, _) if addr >= e => false, [INFO] [stderr] 741 | | _ => true [INFO] [stderr] 742 | | } [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] 739 | match *self { [INFO] [stderr] 740 | Addr::StackCell(addr, _) if addr >= e => false, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:804:9 [INFO] [stderr] | [INFO] [stderr] 804 | / match self { [INFO] [stderr] 805 | | &HeapCellValue::Addr(ref a) => a.clone(), [INFO] [stderr] 806 | | &HeapCellValue::NamedStr(_, _, _) => Addr::Str(focus) [INFO] [stderr] 807 | | } [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] 804 | match *self { [INFO] [stderr] 805 | HeapCellValue::Addr(ref a) => a.clone(), [INFO] [stderr] 806 | HeapCellValue::NamedStr(_, _, _) => Addr::Str(focus) [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:827:9 [INFO] [stderr] | [INFO] [stderr] 827 | / if let &IndexPtr::Undefined = index_ptr { [INFO] [stderr] 828 | | true [INFO] [stderr] 829 | | } else { [INFO] [stderr] 830 | | false [INFO] [stderr] 831 | | } [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] 827 | if let IndexPtr::Undefined = *index_ptr { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:879:9 [INFO] [stderr] | [INFO] [stderr] 879 | / match self { [INFO] [stderr] 880 | | &CodePtr::BuiltInClause(_, ref local) [INFO] [stderr] 881 | | | &CodePtr::CallN(_, ref local) [INFO] [stderr] 882 | | | &CodePtr::Local(ref local) => local.clone() [INFO] [stderr] 883 | | } [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] 879 | match *self { [INFO] [stderr] 880 | CodePtr::BuiltInClause(_, ref local) [INFO] [stderr] 881 | | CodePtr::CallN(_, ref local) [INFO] [stderr] 882 | | CodePtr::Local(ref local) => local.clone() [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/instructions.rs:882:43 [INFO] [stderr] | [INFO] [stderr] 882 | | &CodePtr::Local(ref local) => local.clone() [INFO] [stderr] | ^^^^^^^^^^^^^ help: try dereferencing it: `*local` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::clone_on_copy)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:898:9 [INFO] [stderr] | [INFO] [stderr] 898 | / match cp { [INFO] [stderr] 899 | | CodePtr::Local(local) => *self = local, [INFO] [stderr] 900 | | _ => {} [INFO] [stderr] 901 | | } [INFO] [stderr] | |_________^ help: try this: `if let CodePtr::Local(local) = cp { *self = local }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:958:9 [INFO] [stderr] | [INFO] [stderr] 958 | / match self { [INFO] [stderr] 959 | | &mut LocalCodePtr::InSituDirEntry(ref mut p) [INFO] [stderr] 960 | | | &mut LocalCodePtr::UserGoalExpansion(ref mut p) [INFO] [stderr] 961 | | | &mut LocalCodePtr::UserTermExpansion(ref mut p) [INFO] [stderr] 962 | | | &mut LocalCodePtr::DirEntry(ref mut p) [INFO] [stderr] 963 | | | &mut LocalCodePtr::TopLevel(_, ref mut p) => *p += rhs [INFO] [stderr] 964 | | } [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] 958 | match *self { [INFO] [stderr] 959 | LocalCodePtr::InSituDirEntry(ref mut p) [INFO] [stderr] 960 | | LocalCodePtr::UserGoalExpansion(ref mut p) [INFO] [stderr] 961 | | LocalCodePtr::UserTermExpansion(ref mut p) [INFO] [stderr] 962 | | LocalCodePtr::DirEntry(ref mut p) [INFO] [stderr] 963 | | LocalCodePtr::TopLevel(_, ref mut p) => *p += rhs [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:981:9 [INFO] [stderr] | [INFO] [stderr] 981 | / match self { [INFO] [stderr] 982 | | &mut CodePtr::Local(ref mut local) => *local += rhs, [INFO] [stderr] 983 | | _ => *self = CodePtr::Local(self.local() + rhs) [INFO] [stderr] 984 | | } [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] 981 | match *self { [INFO] [stderr] 982 | CodePtr::Local(ref mut local) => *local += rhs, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1052:9 [INFO] [stderr] | [INFO] [stderr] 1052 | / match term { [INFO] [stderr] 1053 | | &Term::AnonVar => [INFO] [stderr] 1054 | | TermIterState::AnonVar(lvl), [INFO] [stderr] 1055 | | &Term::Clause(ref cell, ref name, ref subterms, fixity) => { [INFO] [stderr] ... | [INFO] [stderr] 1069 | | TermIterState::Var(lvl, cell, var.clone()) [INFO] [stderr] 1070 | | } [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] 1052 | match *term { [INFO] [stderr] 1053 | Term::AnonVar => [INFO] [stderr] 1054 | TermIterState::AnonVar(lvl), [INFO] [stderr] 1055 | Term::Clause(ref cell, ref name, ref subterms, fixity) => { [INFO] [stderr] 1056 | let ct = if let Some(fixity) = fixity { [INFO] [stderr] 1057 | ClauseType::Op(name.clone(), fixity, CodeIndex::default()) [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:1103:13 [INFO] [stderr] | [INFO] [stderr] 1103 | / match self.get_code_index((name.clone(), arity), mod_name.clone()) { [INFO] [stderr] 1104 | | Some(CodeIndex (ref code_idx)) => { [INFO] [stderr] 1105 | | if &code_idx.borrow().1 != &module.module_decl.name { [INFO] [stderr] 1106 | | continue; [INFO] [stderr] ... | [INFO] [stderr] 1135 | | _ => {} [INFO] [stderr] 1136 | | }; [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 1103 | if let Some(CodeIndex (ref code_idx)) = self.get_code_index((name.clone(), arity), mod_name.clone()) { [INFO] [stderr] 1104 | if &code_idx.borrow().1 != &module.module_decl.name { [INFO] [stderr] 1105 | continue; [INFO] [stderr] 1106 | } [INFO] [stderr] 1107 | [INFO] [stderr] 1108 | self.remove_code_index((name.clone(), arity)); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: needlessly taken reference of both operands [INFO] [stderr] --> src/prolog/instructions.rs:1105:24 [INFO] [stderr] | [INFO] [stderr] 1105 | if &code_idx.borrow().1 != &module.module_decl.name { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::op_ref)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#op_ref [INFO] [stderr] help: use the values directly [INFO] [stderr] | [INFO] [stderr] 1105 | if code_idx.borrow().1 != module.module_decl.name { [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/prolog/instructions.rs:1174:69 [INFO] [stderr] | [INFO] [stderr] 1174 | fn use_qualified_module(&mut self, submodule: &Module, exports: &Vec) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateKey]` [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: large size difference between variants [INFO] [stderr] --> src/prolog/instructions.rs:1225:5 [INFO] [stderr] | [INFO] [stderr] 1225 | Hook(CompileTimeHook, PredicateClause, VecDeque), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::large_enum_variant)] on by default [INFO] [stderr] help: consider boxing the large fields to reduce the total size of the enum [INFO] [stderr] --> src/prolog/instructions.rs:1225:5 [INFO] [stderr] | [INFO] [stderr] 1225 | Hook(CompileTimeHook, PredicateClause, VecDeque), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1236:9 [INFO] [stderr] | [INFO] [stderr] 1236 | if let &Declaration::Module(_) = self { true } else { false } [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] 1236 | if let Declaration::Module(_) = *self { true } else { false } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ [INFO] [stderr] [INFO] [stderr] warning: large size difference between variants [INFO] [stderr] --> src/prolog/instructions.rs:1241:5 [INFO] [stderr] | [INFO] [stderr] 1241 | Declaration(Declaration), [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [INFO] [stderr] help: consider boxing the large fields to reduce the total size of the enum [INFO] [stderr] | [INFO] [stderr] 1241 | Declaration(Box), [INFO] [stderr] | ^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1250:9 [INFO] [stderr] | [INFO] [stderr] 1250 | / match self { [INFO] [stderr] 1251 | | &TopLevel::Declaration(_) => None, [INFO] [stderr] 1252 | | &TopLevel::Fact(ref term) => term.name(), [INFO] [stderr] 1253 | | &TopLevel::Predicate(ref clauses) => [INFO] [stderr] ... | [INFO] [stderr] 1257 | | Some(head.0.clone()) [INFO] [stderr] 1258 | | } [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] 1250 | match *self { [INFO] [stderr] 1251 | TopLevel::Declaration(_) => None, [INFO] [stderr] 1252 | TopLevel::Fact(ref term) => term.name(), [INFO] [stderr] 1253 | TopLevel::Predicate(ref clauses) => [INFO] [stderr] 1254 | clauses.0.first().and_then(|ref term| term.name()), [INFO] [stderr] 1255 | TopLevel::Query(_) => None, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1262:9 [INFO] [stderr] | [INFO] [stderr] 1262 | / match self { [INFO] [stderr] 1263 | | &TopLevel::Declaration(_) => 0, [INFO] [stderr] 1264 | | &TopLevel::Fact(ref term) => term.arity(), [INFO] [stderr] 1265 | | &TopLevel::Predicate(ref clauses) => [INFO] [stderr] ... | [INFO] [stderr] 1268 | | &TopLevel::Rule(Rule { ref head, .. }) => head.1.len() [INFO] [stderr] 1269 | | } [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] 1262 | match *self { [INFO] [stderr] 1263 | TopLevel::Declaration(_) => 0, [INFO] [stderr] 1264 | TopLevel::Fact(ref term) => term.arity(), [INFO] [stderr] 1265 | TopLevel::Predicate(ref clauses) => [INFO] [stderr] 1266 | clauses.0.first().map(|t| t.arity()).unwrap_or(0), [INFO] [stderr] 1267 | TopLevel::Query(_) => 0, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/instructions.rs:1302:9 [INFO] [stderr] | [INFO] [stderr] 1302 | / match self { [INFO] [stderr] 1303 | | &VarData::Temp(_, r, _) => RegType::Temp(r), [INFO] [stderr] 1304 | | &VarData::Perm(r) => RegType::Perm(r) [INFO] [stderr] 1305 | | } [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] 1302 | match *self { [INFO] [stderr] 1303 | VarData::Temp(_, r, _) => RegType::Temp(r), [INFO] [stderr] 1304 | VarData::Perm(r) => RegType::Perm(r) [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:1399:13 [INFO] [stderr] | [INFO] [stderr] 1399 | / match op_dir.get(&(name.clone(), Fixity::Post)) { [INFO] [stderr] 1400 | | Some(_) => return Err(SessionError::OpIsInfixAndPostFix), [INFO] [stderr] 1401 | | _ => {} [INFO] [stderr] 1402 | | }; [INFO] [stderr] | |_____________^ help: try this: `if let Some(_) = op_dir.get(&(name.clone(), Fixity::Post)) { return Err(SessionError::OpIsInfixAndPostFix) }` [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: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/instructions.rs:1406:13 [INFO] [stderr] | [INFO] [stderr] 1406 | / match op_dir.get(&(name.clone(), Fixity::In)) { [INFO] [stderr] 1407 | | Some(_) => return Err(SessionError::OpIsInfixAndPostFix), [INFO] [stderr] 1408 | | _ => {} [INFO] [stderr] 1409 | | }; [INFO] [stderr] | |_____________^ help: try this: `if let Some(_) = op_dir.get(&(name.clone(), Fixity::In)) { return Err(SessionError::OpIsInfixAndPostFix) }` [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: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/and_stack.rs:20:20 [INFO] [stderr] | [INFO] [stderr] 20 | perms: (1 .. n+1).map(|i| Addr::StackCell(fr, i)).collect() [INFO] [stderr] | ^^^^^^^^^^ help: use: `(1..=n)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::range_plus_one)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: this function has too many arguments (8/7) [INFO] [stderr] --> src/prolog/allocator.rs:18:5 [INFO] [stderr] | [INFO] [stderr] 18 | / fn mark_reserved_var(&mut self, Rc, Level, &'a Cell, GenContext, [INFO] [stderr] 19 | | &mut Vec, RegType, bool) [INFO] [stderr] 20 | | where Target: CompilationTarget<'a>; [INFO] [stderr] | |____________________________________________^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::too_many_arguments)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [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/prolog/allocator.rs:27:33 [INFO] [stderr] | [INFO] [stderr] 27 | fn reset_at_head(&mut self, &Vec>); [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/allocator.rs:64:9 [INFO] [stderr] | [INFO] [stderr] 64 | / match self.bindings_mut().get_mut(&var).unwrap() { [INFO] [stderr] 65 | | &mut VarData::Temp(_, ref mut s, _) => *s = r.reg_num(), [INFO] [stderr] 66 | | &mut VarData::Perm(ref mut s) => *s = r.reg_num() [INFO] [stderr] 67 | | } [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] 64 | match *self.bindings_mut().get_mut(&var).unwrap() { [INFO] [stderr] 65 | VarData::Temp(_, ref mut s, _) => *s = r.reg_num(), [INFO] [stderr] 66 | VarData::Perm(ref mut s) => *s = r.reg_num() [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/toplevel.rs:41:17 [INFO] [stderr] | [INFO] [stderr] 41 | / match &self.static_code_dir { [INFO] [stderr] 42 | | &Some(ref code_dir) => code_dir.get(&(name.clone(), arity)), [INFO] [stderr] 43 | | _ => None [INFO] [stderr] 44 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 41 | match self.static_code_dir { [INFO] [stderr] 42 | Some(ref code_dir) => code_dir.get(&(name.clone(), arity)), [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/prolog/toplevel.rs:83:51 [INFO] [stderr] | [INFO] [stderr] 83 | fn is_compile_time_hook(name: &ClauseName, terms: &Vec>) -> Option { [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/toplevel.rs:86:13 [INFO] [stderr] | [INFO] [stderr] 86 | / if let &Term::Clause(_, ref name, ref terms, None) = term.as_ref() { [INFO] [stderr] 87 | | return get_compile_time_hook(name.as_str(), terms.len()); [INFO] [stderr] 88 | | } [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] 86 | if let Term::Clause(_, ref name, ref terms, None) = *term.as_ref() { [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/prolog/toplevel.rs:246:42 [INFO] [stderr] | [INFO] [stderr] 246 | fn is_consistent(tl: &TopLevel, clauses: &Vec) -> bool [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateClause]` [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/prolog/toplevel.rs:308:9 [INFO] [stderr] | [INFO] [stderr] 308 | / match term { [INFO] [stderr] 309 | | &mut Term::Constant(_, Constant::Atom(ref mut var, _)) if var.as_str() == "!" => [INFO] [stderr] 310 | | *var = name.clone(), [INFO] [stderr] 311 | | _ => {} [INFO] [stderr] 312 | | } [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] 308 | match *term { [INFO] [stderr] 309 | Term::Constant(_, Constant::Atom(ref mut var, _)) if var.as_str() == "!" => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/toplevel.rs:317:25 [INFO] [stderr] | [INFO] [stderr] 317 | let cut_var_found = match term { [INFO] [stderr] | _________________________^ [INFO] [stderr] 318 | | &mut Term::Constant(_, Constant::Atom(ref var, _)) if var.as_str() == "!" => true, [INFO] [stderr] 319 | | _ => false [INFO] [stderr] 320 | | }; [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] 317 | let cut_var_found = match *term { [INFO] [stderr] 318 | Term::Constant(_, Constant::Atom(ref var, _)) if var.as_str() == "!" => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: large size difference between variants [INFO] [stderr] --> src/prolog/toplevel.rs:354:5 [INFO] [stderr] | [INFO] [stderr] 354 | Decl(TopLevel, VecDeque) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] help: consider boxing the large fields to reduce the total size of the enum [INFO] [stderr] --> src/prolog/toplevel.rs:354:5 [INFO] [stderr] | [INFO] [stderr] 354 | Decl(TopLevel, VecDeque) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant [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/prolog/toplevel.rs:382:41 [INFO] [stderr] | [INFO] [stderr] 382 | fn fabricate_rule_body(&self, vars: &Vec, body_term: Term) -> Term [INFO] [stderr] | ^^^^^^^^^^ help: change this to: `&[Term]` [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: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name [INFO] [stderr] --> src/prolog/toplevel.rs:455:22 [INFO] [stderr] | [INFO] [stderr] 455 | fn to_query_term(&mut self, indices: &mut CompositeIndices, term: Term) -> Result [INFO] [stderr] | ^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::wrong_self_convention)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/toplevel.rs:571:17 [INFO] [stderr] | [INFO] [stderr] 571 | / if let &mut Term::Clause(_, ref name, ref mut subterms, _) = &mut term { [INFO] [stderr] 572 | | if name.as_str() == "->" && subterms.len() == 2 { [INFO] [stderr] 573 | | let conq = *subterms.pop().unwrap(); [INFO] [stderr] 574 | | let prec = *subterms.pop().unwrap(); [INFO] [stderr] ... | [INFO] [stderr] 578 | | } [INFO] [stderr] 579 | | } [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] 571 | if let Term::Clause(_, ref name, ref mut subterms, _) = *(&mut term) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: The function/method `Some` doesn't need a mutable reference [INFO] [stderr] --> src/prolog/toplevel.rs:703:58 [INFO] [stderr] | [INFO] [stderr] 703 | let mut indices = composite_indices!(false, indices, &mut code_dir); [INFO] [stderr] | ^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unnecessary_mut_passed)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed [INFO] [stderr] [INFO] [stderr] warning: The function/method `Some` doesn't need a mutable reference [INFO] [stderr] --> src/prolog/toplevel.rs:745:36 [INFO] [stderr] | [INFO] [stderr] 745 | &mut self.term_stream.indices.code_dir); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed [INFO] [stderr] [INFO] [stderr] warning: The function/method `Some` doesn't need a mutable reference [INFO] [stderr] --> src/prolog/toplevel.rs:775:36 [INFO] [stderr] | [INFO] [stderr] 775 | &mut self.term_stream.indices.code_dir); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/machine_state.rs:248:30 [INFO] [stderr] | [INFO] [stderr] 248 | Some(ref idx) => if let &IndexPtr::Index(p) = &idx.0.borrow().0 { [INFO] [stderr] | ______________________________^ [INFO] [stderr] 249 | | Some(p) [INFO] [stderr] 250 | | } else { [INFO] [stderr] 251 | | None [INFO] [stderr] 252 | | }, [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: try [INFO] [stderr] | [INFO] [stderr] 248 | Some(ref idx) => if let IndexPtr::Index(p) = idx.0.borrow().0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: this argument is passed by reference, but would be more efficient if passed by value [INFO] [stderr] --> src/prolog/machine/machine_state.rs:660:69 [INFO] [stderr] | [INFO] [stderr] 660 | fn compile_hook(&mut self, machine_st: &mut MachineState, hook: &CompileTimeHook) -> CallResult [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: consider passing by value instead: `CompileTimeHook` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::trivially_copy_pass_by_ref)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state.rs:288:18 [INFO] [stderr] | [INFO] [stderr] 288 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state.rs:293:25 [INFO] [stderr] | [INFO] [stderr] 293 | machine_st.cp = machine_st.or_stack[b].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `machine_st.or_stack[b].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state.rs:326:18 [INFO] [stderr] | [INFO] [stderr] 326 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state.rs:331:25 [INFO] [stderr] | [INFO] [stderr] 331 | machine_st.cp = machine_st.or_stack[b].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `machine_st.or_stack[b].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state.rs:364:18 [INFO] [stderr] | [INFO] [stderr] 364 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state.rs:369:25 [INFO] [stderr] | [INFO] [stderr] 369 | machine_st.cp = machine_st.or_stack[b].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `machine_st.or_stack[b].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state.rs:403:18 [INFO] [stderr] | [INFO] [stderr] 403 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state.rs:408:25 [INFO] [stderr] | [INFO] [stderr] 408 | machine_st.cp = machine_st.or_stack[b].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `machine_st.or_stack[b].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state.rs:513:9 [INFO] [stderr] | [INFO] [stderr] 513 | / match ct { [INFO] [stderr] 514 | | &BuiltInClauseType::AcyclicTerm => { [INFO] [stderr] 515 | | let addr = machine_st[temp_v!(1)].clone(); [INFO] [stderr] 516 | | machine_st.fail = machine_st.is_cyclic_term(addr); [INFO] [stderr] ... | [INFO] [stderr] 656 | | }, [INFO] [stderr] 657 | | } [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] 513 | match *ct { [INFO] [stderr] 514 | BuiltInClauseType::AcyclicTerm => { [INFO] [stderr] 515 | let addr = machine_st[temp_v!(1)].clone(); [INFO] [stderr] 516 | machine_st.fail = machine_st.is_cyclic_term(addr); [INFO] [stderr] 517 | return_from_clause!(machine_st.last_call, machine_st) [INFO] [stderr] 518 | }, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state.rs:787:40 [INFO] [stderr] | [INFO] [stderr] 787 | pub(crate) fn new_in_place(policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::borrowed_box)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> src/prolog/machine/machine_state.rs:800:45 [INFO] [stderr] | [INFO] [stderr] 800 | if self.inference_limit_exceeded || machine_st.ball.stub.len() > 0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!machine_st.ball.stub.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: methods called `into_*` usually take self by value; consider choosing a less ambiguous name [INFO] [stderr] --> src/prolog/machine/machine_state.rs:845:30 [INFO] [stderr] | [INFO] [stderr] 845 | pub(crate) fn into_inner(&mut self) -> Box { [INFO] [stderr] | ^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:16:5 [INFO] [stderr] | [INFO] [stderr] 16 | / if let &mut Term::Clause(_, ref name, ref mut subterms, _) = term { [INFO] [stderr] 17 | | if name.as_str() == s && subterms.len() == 2 { [INFO] [stderr] 18 | | let snd = *subterms.pop().unwrap(); [INFO] [stderr] 19 | | let fst = *subterms.pop().unwrap(); [INFO] [stderr] ... | [INFO] [stderr] 22 | | } [INFO] [stderr] 23 | | } [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] 16 | if let Term::Clause(_, ref name, ref mut subterms, _) = *term { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ [INFO] [stderr] [INFO] [stderr] warning: local variable doesn't need to be boxed here [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:102:54 [INFO] [stderr] | [INFO] [stderr] 102 | fn extract_from_list(&mut self, head: Box, tail: Box) [INFO] [stderr] | ^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::boxed_local)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local [INFO] [stderr] [INFO] [stderr] warning: local variable doesn't need to be boxed here [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:102:37 [INFO] [stderr] | [INFO] [stderr] 102 | fn extract_from_list(&mut self, head: Box, tail: Box) [INFO] [stderr] | ^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:124:20 [INFO] [stderr] | [INFO] [stderr] 124 | Ok(self.stack.extend(iter)) [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] 124 | Ok(()) [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:127:20 [INFO] [stderr] | [INFO] [stderr] 127 | Ok(self.stack.push(term)), [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] 127 | Ok(()), [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] error: this `if` has identical blocks [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:175:73 [INFO] [stderr] | [INFO] [stderr] 175 | } else if name.as_str() == "?-" && terms.len() == 1 { [INFO] [stderr] | _________________________________________________________________________^ [INFO] [stderr] 176 | | let comma_term = *terms.pop().unwrap(); [INFO] [stderr] 177 | | unfold_by_str(comma_term, ",") [INFO] [stderr] 178 | | } else { [INFO] [stderr] | |_____________________^ [INFO] [stderr] | [INFO] [stderr] = note: #[deny(clippy::if_same_then_else)] on by default [INFO] [stderr] note: same as this [INFO] [stderr] --> src/prolog/machine/term_expansion.rs:172:82 [INFO] [stderr] | [INFO] [stderr] 172 | let old_terms = if name.as_str() == ":-" && terms.len() == 2 { [INFO] [stderr] | __________________________________________________________________________________^ [INFO] [stderr] 173 | | let comma_term = *terms.pop().unwrap(); [INFO] [stderr] 174 | | unfold_by_str(comma_term, ",") [INFO] [stderr] 175 | | } else if name.as_str() == "?-" && terms.len() == 1 { [INFO] [stderr] | |_____________________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:224:25 [INFO] [stderr] | [INFO] [stderr] 224 | / if let &HeapCellValue::NamedStr(n2, ref f2, _) = &self.heap[a2] { [INFO] [stderr] 225 | | if f2.as_str() == "." && n2 == 2 { [INFO] [stderr] 226 | | pdl.push(Addr::HeapCell(a1)); [INFO] [stderr] 227 | | pdl.push(Addr::HeapCell(a2 + 1)); [INFO] [stderr] ... | [INFO] [stderr] 233 | | } [INFO] [stderr] 234 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 224 | if let HeapCellValue::NamedStr(n2, ref f2, _) = self.heap[a2] { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:309:25 [INFO] [stderr] | [INFO] [stderr] 309 | / if let &HeapCellValue::NamedStr(n1, ref f1, _) = r1 { [INFO] [stderr] 310 | | if let &HeapCellValue::NamedStr(n2, ref f2, _) = r2 { [INFO] [stderr] 311 | | if n1 == n2 && *f1 == *f2 { [INFO] [stderr] 312 | | for i in 1 .. n1 + 1 { [INFO] [stderr] ... | [INFO] [stderr] 319 | | } [INFO] [stderr] 320 | | } [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] 309 | if let HeapCellValue::NamedStr(n1, ref f1, _) = *r1 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:310:29 [INFO] [stderr] | [INFO] [stderr] 310 | / if let &HeapCellValue::NamedStr(n2, ref f2, _) = r2 { [INFO] [stderr] 311 | | if n1 == n2 && *f1 == *f2 { [INFO] [stderr] 312 | | for i in 1 .. n1 + 1 { [INFO] [stderr] 313 | | pdl.push(Addr::HeapCell(a1 + i)); [INFO] [stderr] ... | [INFO] [stderr] 318 | | } [INFO] [stderr] 319 | | } [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] 310 | if let HeapCellValue::NamedStr(n2, ref f2, _) = *r2 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:312:46 [INFO] [stderr] | [INFO] [stderr] 312 | for i in 1 .. n1 + 1 { [INFO] [stderr] | ^^^^^^^^^^^ help: use: `1..=n1` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:509:9 [INFO] [stderr] | [INFO] [stderr] 509 | / match at { [INFO] [stderr] 510 | | &ArithmeticTerm::Reg(r) => self.arith_eval_by_metacall(r), [INFO] [stderr] 511 | | &ArithmeticTerm::Interm(i) => Ok(self.interms[i-1].clone()), [INFO] [stderr] 512 | | &ArithmeticTerm::Number(ref n) => Ok(n.clone()), [INFO] [stderr] 513 | | } [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] 509 | match *at { [INFO] [stderr] 510 | ArithmeticTerm::Reg(r) => self.arith_eval_by_metacall(r), [INFO] [stderr] 511 | ArithmeticTerm::Interm(i) => Ok(self.interms[i-1].clone()), [INFO] [stderr] 512 | ArithmeticTerm::Number(ref n) => Ok(n.clone()), [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/prolog/machine/machine_state_impl.rs:516:57 [INFO] [stderr] | [INFO] [stderr] 516 | fn get_rational(&self, at: &ArithmeticTerm, caller: &MachineStub) [INFO] [stderr] | ^^^^^^^^^^^^ [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/prolog/machine/machine_state_impl.rs:826:9 [INFO] [stderr] | [INFO] [stderr] 826 | / match instr { [INFO] [stderr] 827 | | &ArithmeticInstruction::Add(ref a1, ref a2, t) => { [INFO] [stderr] 828 | | let n1 = try_or_fail!(self, self.get_number(a1)); [INFO] [stderr] 829 | | let n2 = try_or_fail!(self, self.get_number(a2)); [INFO] [stderr] ... | [INFO] [stderr] 945 | | } [INFO] [stderr] 946 | | }; [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] 826 | match *instr { [INFO] [stderr] 827 | ArithmeticInstruction::Add(ref a1, ref a2, t) => { [INFO] [stderr] 828 | let n1 = try_or_fail!(self, self.get_number(a1)); [INFO] [stderr] 829 | let n2 = try_or_fail!(self, self.get_number(a2)); [INFO] [stderr] 830 | [INFO] [stderr] 831 | self.interms[t - 1] = n1 + n2; [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:950:9 [INFO] [stderr] | [INFO] [stderr] 950 | / match instr { [INFO] [stderr] 951 | | &FactInstruction::GetConstant(_, ref c, reg) => { [INFO] [stderr] 952 | | let addr = self[reg].clone(); [INFO] [stderr] 953 | | self.write_constant_to_var(addr, c.clone()); [INFO] [stderr] ... | [INFO] [stderr] 1123 | | } [INFO] [stderr] 1124 | | }; [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] 950 | match *instr { [INFO] [stderr] 951 | FactInstruction::GetConstant(_, ref c, reg) => { [INFO] [stderr] 952 | let addr = self[reg].clone(); [INFO] [stderr] 953 | self.write_constant_to_var(addr, c.clone()); [INFO] [stderr] 954 | }, [INFO] [stderr] 955 | FactInstruction::GetList(_, reg) => { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1008:25 [INFO] [stderr] | [INFO] [stderr] 1008 | / if let &HeapCellValue::NamedStr(narity, ref s, _) = result { [INFO] [stderr] 1009 | | if narity == arity && ct.name() == *s { [INFO] [stderr] 1010 | | self.s = a + 1; [INFO] [stderr] 1011 | | self.mode = MachineMode::Read; [INFO] [stderr] ... | [INFO] [stderr] 1014 | | } [INFO] [stderr] 1015 | | } [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] 1008 | if let HeapCellValue::NamedStr(narity, ref s, _) = *result { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1128:9 [INFO] [stderr] | [INFO] [stderr] 1128 | / match instr { [INFO] [stderr] 1129 | | &IndexingInstruction::SwitchOnTerm(v, c, l, s) => { [INFO] [stderr] 1130 | | let a1 = self.registers[1].clone(); [INFO] [stderr] 1131 | | let addr = self.store(self.deref(a1)); [INFO] [stderr] ... | [INFO] [stderr] 1187 | | } [INFO] [stderr] 1188 | | }; [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] 1128 | match *instr { [INFO] [stderr] 1129 | IndexingInstruction::SwitchOnTerm(v, c, l, s) => { [INFO] [stderr] 1130 | let a1 = self.registers[1].clone(); [INFO] [stderr] 1131 | let addr = self.store(self.deref(a1)); [INFO] [stderr] 1132 | [INFO] [stderr] 1133 | let offset = match addr { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1171:25 [INFO] [stderr] | [INFO] [stderr] 1171 | / if let &HeapCellValue::NamedStr(arity, ref name, _) = &self.heap[s] { [INFO] [stderr] 1172 | | match hm.get(&(name.clone(), arity)) { [INFO] [stderr] 1173 | | Some(offset) => *offset, [INFO] [stderr] 1174 | | _ => 0 [INFO] [stderr] ... | [INFO] [stderr] 1177 | | 0 [INFO] [stderr] 1178 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 1171 | if let HeapCellValue::NamedStr(arity, ref name, _) = self.heap[s] { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1192:9 [INFO] [stderr] | [INFO] [stderr] 1192 | / match instr { [INFO] [stderr] 1193 | | &QueryInstruction::GetVariable(norm, arg) => [INFO] [stderr] 1194 | | self[norm] = self.registers[arg].clone(), [INFO] [stderr] 1195 | | &QueryInstruction::PutConstant(_, ref constant, reg) => [INFO] [stderr] ... | [INFO] [stderr] 1271 | | } [INFO] [stderr] 1272 | | } [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] 1192 | match *instr { [INFO] [stderr] 1193 | QueryInstruction::GetVariable(norm, arg) => [INFO] [stderr] 1194 | self[norm] = self.registers[arg].clone(), [INFO] [stderr] 1195 | QueryInstruction::PutConstant(_, ref constant, reg) => [INFO] [stderr] 1196 | self[reg] = Addr::Con(constant.clone()), [INFO] [stderr] 1197 | QueryInstruction::PutList(_, reg) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1322:30 [INFO] [stderr] | [INFO] [stderr] 1322 | for i in 1 .. narity + 1 { [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: use: `1..=narity` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1686:9 [INFO] [stderr] | [INFO] [stderr] 1686 | / match inlined { [INFO] [stderr] 1687 | | &InlinedClauseType::CompareNumber(cmp, ref at_1, ref at_2) => { [INFO] [stderr] 1688 | | let n1 = try_or_fail!(self, self.get_number(at_1)); [INFO] [stderr] 1689 | | let n2 = try_or_fail!(self, self.get_number(at_2)); [INFO] [stderr] ... | [INFO] [stderr] 1772 | | } [INFO] [stderr] 1773 | | } [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] 1686 | match *inlined { [INFO] [stderr] 1687 | InlinedClauseType::CompareNumber(cmp, ref at_1, ref at_2) => { [INFO] [stderr] 1688 | let n1 = try_or_fail!(self, self.get_number(at_1)); [INFO] [stderr] 1689 | let n2 = try_or_fail!(self, self.get_number(at_2)); [INFO] [stderr] 1690 | [INFO] [stderr] 1691 | self.compare_numbers(cmp, n1, n2); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:1889:54 [INFO] [stderr] | [INFO] [stderr] 1889 | pub(super) fn to_list>(&mut self, values: Iter) -> usize { [INFO] [stderr] | ^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2103:44 [INFO] [stderr] | [INFO] [stderr] 2103 | self.and_stack[index].cp = self.cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2113:41 [INFO] [stderr] | [INFO] [stderr] 2113 | self.and_stack.push(gi, self.e, self.cp.clone(), num_cells); [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2120:19 [INFO] [stderr] | [INFO] [stderr] 2120 | self.cp = self.and_stack[e].cp.clone(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.and_stack[e].cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2127:40 [INFO] [stderr] | [INFO] [stderr] 2127 | call_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2128:40 [INFO] [stderr] | [INFO] [stderr] 2128 | cut_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: try: `&mut CutPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: this function has too many arguments (8/7) [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2126:5 [INFO] [stderr] | [INFO] [stderr] 2126 | / fn handle_call_clause(&mut self, indices: &mut IndexStore, [INFO] [stderr] 2127 | | call_policy: &mut Box, [INFO] [stderr] 2128 | | cut_policy: &mut Box, [INFO] [stderr] 2129 | | ct: &ClauseType, [INFO] [stderr] ... | [INFO] [stderr] 2157 | | }; [INFO] [stderr] 2158 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2143:9 [INFO] [stderr] | [INFO] [stderr] 2143 | / match ct { [INFO] [stderr] 2144 | | &ClauseType::BuiltIn(ref ct) => [INFO] [stderr] 2145 | | try_or_fail!(self, call_policy.call_builtin(self, ct, indices)), [INFO] [stderr] 2146 | | &ClauseType::CallN => [INFO] [stderr] ... | [INFO] [stderr] 2156 | | try_or_fail!(self, self.system_call(ct, indices, call_policy, cut_policy)) [INFO] [stderr] 2157 | | }; [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] 2143 | match *ct { [INFO] [stderr] 2144 | ClauseType::BuiltIn(ref ct) => [INFO] [stderr] 2145 | try_or_fail!(self, call_policy.call_builtin(self, ct, indices)), [INFO] [stderr] 2146 | ClauseType::CallN => [INFO] [stderr] 2147 | try_or_fail!(self, call_policy.call_n(self, arity, indices)), [INFO] [stderr] 2148 | ClauseType::Hook(ref hook) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2161:51 [INFO] [stderr] | [INFO] [stderr] 2161 | call_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2162:51 [INFO] [stderr] | [INFO] [stderr] 2162 | cut_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: try: `&mut CutPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2165:9 [INFO] [stderr] | [INFO] [stderr] 2165 | / match instr { [INFO] [stderr] 2166 | | &ControlInstruction::Allocate(num_cells) => [INFO] [stderr] 2167 | | self.allocate(num_cells), [INFO] [stderr] 2168 | | &ControlInstruction::CallClause(ref ct, arity, _, lco, use_default_cp) => [INFO] [stderr] ... | [INFO] [stderr] 2182 | | self.p = CodePtr::Local(self.cp.clone()) [INFO] [stderr] 2183 | | }; [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] 2165 | match *instr { [INFO] [stderr] 2166 | ControlInstruction::Allocate(num_cells) => [INFO] [stderr] 2167 | self.allocate(num_cells), [INFO] [stderr] 2168 | ControlInstruction::CallClause(ref ct, arity, _, lco, use_default_cp) => [INFO] [stderr] 2169 | self.handle_call_clause(indices, call_policy, cut_policy, [INFO] [stderr] 2170 | ct, arity, lco, use_default_cp), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2182:41 [INFO] [stderr] | [INFO] [stderr] 2182 | self.p = CodePtr::Local(self.cp.clone()) [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2187:61 [INFO] [stderr] | [INFO] [stderr] 2187 | call_policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2189:9 [INFO] [stderr] | [INFO] [stderr] 2189 | / match instr { [INFO] [stderr] 2190 | | &IndexedChoiceInstruction::Try(l) => { [INFO] [stderr] 2191 | | let n = self.num_of_args; [INFO] [stderr] 2192 | | let gi = self.next_global_index(); [INFO] [stderr] ... | [INFO] [stderr] 2218 | | try_or_fail!(self, call_policy.trust(self, l)) [INFO] [stderr] 2219 | | }; [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] 2189 | match *instr { [INFO] [stderr] 2190 | IndexedChoiceInstruction::Try(l) => { [INFO] [stderr] 2191 | let n = self.num_of_args; [INFO] [stderr] 2192 | let gi = self.next_global_index(); [INFO] [stderr] 2193 | [INFO] [stderr] 2194 | self.or_stack.push(gi, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2196:36 [INFO] [stderr] | [INFO] [stderr] 2196 | self.cp.clone(), [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2208:26 [INFO] [stderr] | [INFO] [stderr] 2208 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2223:53 [INFO] [stderr] | [INFO] [stderr] 2223 | call_policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2225:9 [INFO] [stderr] | [INFO] [stderr] 2225 | / match instr { [INFO] [stderr] 2226 | | &ChoiceInstruction::TryMeElse(offset) => { [INFO] [stderr] 2227 | | let n = self.num_of_args; [INFO] [stderr] 2228 | | let gi = self.next_global_index(); [INFO] [stderr] ... | [INFO] [stderr] 2262 | | try_or_fail!(self, call_policy.trust_me(self)) [INFO] [stderr] 2263 | | } [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] 2225 | match *instr { [INFO] [stderr] 2226 | ChoiceInstruction::TryMeElse(offset) => { [INFO] [stderr] 2227 | let n = self.num_of_args; [INFO] [stderr] 2228 | let gi = self.next_global_index(); [INFO] [stderr] 2229 | [INFO] [stderr] 2230 | self.or_stack.push(gi, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2232:36 [INFO] [stderr] | [INFO] [stderr] 2232 | self.cp.clone(), [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2244:26 [INFO] [stderr] | [INFO] [stderr] 2244 | for i in 1 .. n + 1 { [INFO] [stderr] | ^^^^^^^^^^ help: use: `1..=n` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2267:49 [INFO] [stderr] | [INFO] [stderr] 2267 | cut_policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: try: `&mut CutPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/machine_state_impl.rs:2269:9 [INFO] [stderr] | [INFO] [stderr] 2269 | / match instr { [INFO] [stderr] 2270 | | &CutInstruction::NeckCut => { [INFO] [stderr] 2271 | | let b = self.b; [INFO] [stderr] 2272 | | let b0 = self.b0; [INFO] [stderr] ... | [INFO] [stderr] 2298 | | } [INFO] [stderr] 2299 | | } [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] 2269 | match *instr { [INFO] [stderr] 2270 | CutInstruction::NeckCut => { [INFO] [stderr] 2271 | let b = self.b; [INFO] [stderr] 2272 | let b0 = self.b0; [INFO] [stderr] 2273 | [INFO] [stderr] 2274 | if b > b0 { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: using `clone` on a `Copy` type [INFO] [stderr] --> src/prolog/machine/system_calls.rs:185:37 [INFO] [stderr] | [INFO] [stderr] 185 | self.p = CodePtr::Local(self.cp.clone()); [INFO] [stderr] | ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `self.cp` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/system_calls.rs:193:44 [INFO] [stderr] | [INFO] [stderr] 193 | call_policy: &mut Box, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut CallPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use `&Box`. Consider using just `&T` [INFO] [stderr] --> src/prolog/machine/system_calls.rs:194:44 [INFO] [stderr] | [INFO] [stderr] 194 | cut_policy: &mut Box) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ help: try: `&mut CutPolicy` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 32 [INFO] [stderr] --> src/prolog/machine/system_calls.rs:191:5 [INFO] [stderr] | [INFO] [stderr] 191 | / pub(super) fn system_call(&mut self, ct: &SystemClauseType, [INFO] [stderr] 192 | | indices: &IndexStore, [INFO] [stderr] 193 | | call_policy: &mut Box, [INFO] [stderr] 194 | | cut_policy: &mut Box) [INFO] [stderr] ... | [INFO] [stderr] 518 | | Ok(()) [INFO] [stderr] 519 | | } [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/system_calls.rs:197:9 [INFO] [stderr] | [INFO] [stderr] 197 | / match ct { [INFO] [stderr] 198 | | &SystemClauseType::CheckCutPoint => { [INFO] [stderr] 199 | | let addr = self.store(self.deref(self[temp_v!(1)].clone())); [INFO] [stderr] 200 | | [INFO] [stderr] ... | [INFO] [stderr] 513 | | } [INFO] [stderr] 514 | | }; [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] 197 | match *ct { [INFO] [stderr] 198 | SystemClauseType::CheckCutPoint => { [INFO] [stderr] 199 | let addr = self.store(self.deref(self[temp_v!(1)].clone())); [INFO] [stderr] 200 | [INFO] [stderr] 201 | match addr { [INFO] [stderr] 202 | Addr::Con(Constant::Usize(old_b)) if self.b <= old_b + 2 => {}, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> src/prolog/machine/system_calls.rs:404:20 [INFO] [stderr] | [INFO] [stderr] 404 | if self.ball.stub.len() > 0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!self.ball.stub.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: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/system_calls.rs:499:17 [INFO] [stderr] | [INFO] [stderr] 499 | / if let &Addr::Con(Constant::Atom(ref name, ..)) = &ignore_ops { [INFO] [stderr] 500 | | printer.ignore_ops = name.as_str() == "true"; [INFO] [stderr] 501 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 499 | if let Addr::Con(Constant::Atom(ref name, ..)) = ignore_ops { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/system_calls.rs:503:17 [INFO] [stderr] | [INFO] [stderr] 503 | / if let &Addr::Con(Constant::Atom(ref name, ..)) = &numbervars { [INFO] [stderr] 504 | | printer.numbervars = name.as_str() == "true"; [INFO] [stderr] 505 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 503 | if let Addr::Con(Constant::Atom(ref name, ..)) = numbervars { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/system_calls.rs:507:17 [INFO] [stderr] | [INFO] [stderr] 507 | / if let &Addr::Con(Constant::Atom(ref name, ..)) = "ed { [INFO] [stderr] 508 | | printer.quoted = name.as_str() == "true"; [INFO] [stderr] 509 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 507 | if let Addr::Con(Constant::Atom(ref name, ..)) = quoted { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:43:9 [INFO] [stderr] | [INFO] [stderr] 43 | / match self { [INFO] [stderr] 44 | | &RefOrOwned::Borrowed(r) => r, [INFO] [stderr] 45 | | &RefOrOwned::Owned(ref r) => r [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] 43 | match *self { [INFO] [stderr] 44 | RefOrOwned::Borrowed(r) => r, [INFO] [stderr] 45 | RefOrOwned::Owned(ref r) => r [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:162:9 [INFO] [stderr] | [INFO] [stderr] 162 | / match p { [INFO] [stderr] 163 | | &CodePtr::Local(LocalCodePtr::UserGoalExpansion(p)) => [INFO] [stderr] 164 | | if p < self.goal_expanders.len() { [INFO] [stderr] 165 | | Some(RefOrOwned::Borrowed(&self.goal_expanders[p])) [INFO] [stderr] ... | [INFO] [stderr] 194 | | } [INFO] [stderr] 195 | | } [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] 162 | match *p { [INFO] [stderr] 163 | CodePtr::Local(LocalCodePtr::UserGoalExpansion(p)) => [INFO] [stderr] 164 | if p < self.goal_expanders.len() { [INFO] [stderr] 165 | Some(RefOrOwned::Borrowed(&self.goal_expanders[p])) [INFO] [stderr] 166 | } else { [INFO] [stderr] 167 | None [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> src/prolog/machine/mod.rs:382:12 [INFO] [stderr] | [INFO] [stderr] 382 | if self.machine_st.ball.stub.len() > 0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!self.machine_st.ball.stub.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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:472:9 [INFO] [stderr] | [INFO] [stderr] 472 | / match instr.as_ref() { [INFO] [stderr] 473 | | &Line::Arithmetic(ref arith_instr) => [INFO] [stderr] 474 | | self.execute_arith_instr(arith_instr), [INFO] [stderr] 475 | | &Line::Choice(ref choice_instr) => [INFO] [stderr] ... | [INFO] [stderr] 507 | | } [INFO] [stderr] 508 | | } [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] 472 | match *instr.as_ref() { [INFO] [stderr] 473 | Line::Arithmetic(ref arith_instr) => [INFO] [stderr] 474 | self.execute_arith_instr(arith_instr), [INFO] [stderr] 475 | Line::Choice(ref choice_instr) => [INFO] [stderr] 476 | self.execute_choice_instr(choice_instr, &mut policies.call_policy), [INFO] [stderr] 477 | Line::Cut(ref cut_instr) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:563:13 [INFO] [stderr] | [INFO] [stderr] 563 | / match var_data { [INFO] [stderr] 564 | | &VarData::Perm(p) if p > 0 => { [INFO] [stderr] 565 | | let e = self.e; [INFO] [stderr] 566 | | let r = var_data.as_reg_type().reg_num(); [INFO] [stderr] ... | [INFO] [stderr] 579 | | _ => {} [INFO] [stderr] 580 | | } [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] 563 | match *var_data { [INFO] [stderr] 564 | VarData::Perm(p) if p > 0 => { [INFO] [stderr] 565 | let e = self.e; [INFO] [stderr] 566 | let r = var_data.as_reg_type().reg_num(); [INFO] [stderr] 567 | let addr = self.and_stack[e][r].clone(); [INFO] [stderr] 568 | [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/machine/mod.rs:593:17 [INFO] [stderr] | [INFO] [stderr] 593 | / match &code_repo[LocalCodePtr::TopLevel(cn, p)] { [INFO] [stderr] 594 | | &Line::Control(ref ctrl_instr) if ctrl_instr.is_jump_instr() => { [INFO] [stderr] 595 | | self.record_var_places(cn, alloc_locs, heap_locs); [INFO] [stderr] 596 | | cn += 1; [INFO] [stderr] 597 | | }, [INFO] [stderr] 598 | | _ => {} [INFO] [stderr] 599 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 593 | match code_repo[LocalCodePtr::TopLevel(cn, p)] { [INFO] [stderr] 594 | Line::Control(ref ctrl_instr) if ctrl_instr.is_jump_instr() => { [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/prolog/compile.rs:15:21 [INFO] [stderr] | [INFO] [stderr] 15 | fn print_code(code: &Code) { [INFO] [stderr] | ^^^^^ [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/prolog/compile.rs:17:9 [INFO] [stderr] | [INFO] [stderr] 17 | / match clause { [INFO] [stderr] 18 | | &Line::Arithmetic(ref arith) => [INFO] [stderr] 19 | | println!("{}", arith), [INFO] [stderr] 20 | | &Line::Fact(ref fact) => [INFO] [stderr] ... | [INFO] [stderr] 37 | | } [INFO] [stderr] 38 | | } [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] 17 | match *clause { [INFO] [stderr] 18 | Line::Arithmetic(ref arith) => [INFO] [stderr] 19 | println!("{}", arith), [INFO] [stderr] 20 | Line::Fact(ref fact) => [INFO] [stderr] 21 | for fact_instr in fact { [INFO] [stderr] 22 | println!("{}", fact_instr); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/compile.rs:48:5 [INFO] [stderr] | [INFO] [stderr] 48 | / match tl { [INFO] [stderr] 49 | | &TopLevel::Declaration(_) | &TopLevel::Query(_) => [INFO] [stderr] 50 | | Err(ParserError::ExpectedRel), [INFO] [stderr] 51 | | &TopLevel::Predicate(ref clauses) => [INFO] [stderr] ... | [INFO] [stderr] 56 | | cg.compile_rule(rule) [INFO] [stderr] 57 | | } [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] 48 | match *tl { [INFO] [stderr] 49 | TopLevel::Declaration(_) | TopLevel::Query(_) => [INFO] [stderr] 50 | Err(ParserError::ExpectedRel), [INFO] [stderr] 51 | TopLevel::Predicate(ref clauses) => [INFO] [stderr] 52 | cg.compile_predicate(&clauses.0), [INFO] [stderr] 53 | TopLevel::Fact(ref fact) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/compile.rs:68:9 [INFO] [stderr] | [INFO] [stderr] 68 | / match line { [INFO] [stderr] 69 | | &mut Line::Control(ControlInstruction::JmpBy(_, ref mut offset, ..)) if *offset == 0 => { [INFO] [stderr] 70 | | *offset = code_len - idx; [INFO] [stderr] 71 | | break; [INFO] [stderr] 72 | | }, [INFO] [stderr] 73 | | _ => {} [INFO] [stderr] 74 | | }; [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] 68 | match *line { [INFO] [stderr] 69 | Line::Control(ControlInstruction::JmpBy(_, ref mut offset, ..)) if *offset == 0 => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/compile.rs:163:13 [INFO] [stderr] | [INFO] [stderr] 163 | / if let &mut Some(ref mut module) = &mut self.module { [INFO] [stderr] 164 | | module.remove_module(mod_name, &submodule); [INFO] [stderr] 165 | | module.use_module(&submodule)?; [INFO] [stderr] 166 | | } else { [INFO] [stderr] 167 | | wam_indices.remove_module(clause_name!("user"), &submodule); [INFO] [stderr] 168 | | } [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] 163 | if let Some(ref mut module) = *(&mut self.module) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:170:16 [INFO] [stderr] | [INFO] [stderr] 170 | Ok(wam_indices.insert_module(submodule)) [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] 170 | Ok(()) [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/prolog/compile.rs:176:72 [INFO] [stderr] | [INFO] [stderr] 176 | fn use_qualified_module(&mut self, submodule: ClauseName, exports: &Vec, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateKey]` [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/prolog/compile.rs:185:13 [INFO] [stderr] | [INFO] [stderr] 185 | / if let &mut Some(ref mut module) = &mut self.module { [INFO] [stderr] 186 | | module.remove_module(mod_name, &submodule); [INFO] [stderr] 187 | | module.use_qualified_module(&submodule, exports)?; [INFO] [stderr] 188 | | } else { [INFO] [stderr] 189 | | wam_indices.remove_module(clause_name!("user"), &submodule); [INFO] [stderr] 190 | | } [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] 185 | if let Some(ref mut module) = *(&mut self.module) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:192:16 [INFO] [stderr] | [INFO] [stderr] 192 | Ok(wam_indices.insert_module(submodule)) [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] 192 | Ok(()) [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: use of `or_insert` followed by a function call [INFO] [stderr] --> src/prolog/compile.rs:225:53 [INFO] [stderr] | [INFO] [stderr] 225 | let idx = code_dir.entry((name, arity)).or_insert(CodeIndex::default()); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(CodeIndex::default)` [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: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:278:28 [INFO] [stderr] | [INFO] [stderr] 278 | Ok(code_repo.term_expanders = code), [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] 278 | Ok(()), [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:280:28 [INFO] [stderr] | [INFO] [stderr] 280 | Ok(code_repo.goal_expanders = code) [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] 280 | Ok(()) [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:284:20 [INFO] [stderr] | [INFO] [stderr] 284 | Ok(self.add_non_counted_bt_flag(name, arity)), [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] 284 | Ok(()), [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: passing a unit value to a function [INFO] [stderr] --> src/prolog/compile.rs:296:24 [INFO] [stderr] | [INFO] [stderr] 296 | Ok(self.module = Some(Module::new(module_decl, atom_tbl))) [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] 296 | Ok(()) [INFO] [stderr] | ^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/compile.rs:328:17 [INFO] [stderr] | [INFO] [stderr] 328 | / if let &Some(ref module) = &self.module { [INFO] [stderr] 329 | | worker.term_stream.set_atom_tbl(module.atom_tbl.clone()); [INFO] [stderr] 330 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 328 | if let Some(ref module) = self.module { [INFO] [stderr] | ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/arithmetic.rs:21:21 [INFO] [stderr] | [INFO] [stderr] 21 | let state = match term { [INFO] [stderr] | _____________________^ [INFO] [stderr] 22 | | &Term::AnonVar => [INFO] [stderr] 23 | | return Err(ArithmeticError::InvalidTerm), [INFO] [stderr] 24 | | &Term::Clause(ref cell, ref name, ref terms, fixity) => [INFO] [stderr] ... | [INFO] [stderr] 35 | | TermIterState::Var(Level::Shallow, cell, var.clone()) [INFO] [stderr] 36 | | }; [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] 21 | let state = match *term { [INFO] [stderr] 22 | Term::AnonVar => [INFO] [stderr] 23 | return Err(ArithmeticError::InvalidTerm), [INFO] [stderr] 24 | Term::Clause(ref cell, ref name, ref terms, fixity) => [INFO] [stderr] 25 | match ClauseType::from(name.clone(), terms.len(), fixity) { [INFO] [stderr] 26 | ct @ ClauseType::Named(..) | ct @ ClauseType::Op(..) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/arithmetic.rs:192:9 [INFO] [stderr] | [INFO] [stderr] 192 | / match c { [INFO] [stderr] 193 | | &Constant::Number(ref n) => [INFO] [stderr] 194 | | self.interm.push(ArithmeticTerm::Number(n.clone())), [INFO] [stderr] 195 | | _ => [INFO] [stderr] 196 | | return Err(ArithmeticError::InvalidAtom), [INFO] [stderr] 197 | | } [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] 192 | match *c { [INFO] [stderr] 193 | Constant::Number(ref n) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/codegen.rs:71:34 [INFO] [stderr] | [INFO] [stderr] 71 | fn get_var_count(&self, var: &'a Var) -> usize { [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: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise [INFO] [stderr] --> src/prolog/codegen.rs:72:10 [INFO] [stderr] | [INFO] [stderr] 72 | *self.var_count.get(var).unwrap() [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&self.var_count[var]` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::get_unwrap)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:117:9 [INFO] [stderr] | [INFO] [stderr] 117 | / match subterm { [INFO] [stderr] 118 | | &Term::AnonVar if is_exposed => [INFO] [stderr] 119 | | self.marker.mark_anon_var(Level::Deep, target), [INFO] [stderr] 120 | | &Term::AnonVar => [INFO] [stderr] ... | [INFO] [stderr] 133 | | } [INFO] [stderr] 134 | | }; [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] 117 | match *subterm { [INFO] [stderr] 118 | Term::AnonVar if is_exposed => [INFO] [stderr] 119 | self.marker.mark_anon_var(Level::Deep, target), [INFO] [stderr] 120 | Term::AnonVar => [INFO] [stderr] 121 | Self::add_or_increment_void_instr(target), [INFO] [stderr] 122 | Term::Cons(ref cell, _, _) | Term::Clause(ref cell, _, _, _) => { [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:195:32 [INFO] [stderr] | [INFO] [stderr] 195 | let term_loc = match chunked_term { [INFO] [stderr] | ________________________________^ [INFO] [stderr] 196 | | &ChunkedTerm::HeadClause(..) => GenContext::Head, [INFO] [stderr] 197 | | &ChunkedTerm::BodyTerm(_) => if i < chunked_terms.len() - 1 { [INFO] [stderr] 198 | | GenContext::Mid(chunk_num) [INFO] [stderr] ... | [INFO] [stderr] 201 | | } [INFO] [stderr] 202 | | }; [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] 195 | let term_loc = match *chunked_term { [INFO] [stderr] 196 | ChunkedTerm::HeadClause(..) => GenContext::Head, [INFO] [stderr] 197 | ChunkedTerm::BodyTerm(_) => if i < chunked_terms.len() - 1 { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:222:9 [INFO] [stderr] | [INFO] [stderr] 222 | / match qt { [INFO] [stderr] 223 | | &QueryTerm::Jump(ref vars) => [INFO] [stderr] 224 | | code.push(jmp_call!(vars.len(), 0, pvs)), [INFO] [stderr] 225 | | &QueryTerm::Clause(_, ref ct, ref terms, true) => [INFO] [stderr] ... | [INFO] [stderr] 229 | | _ => {} [INFO] [stderr] 230 | | } [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] 222 | match *qt { [INFO] [stderr] 223 | QueryTerm::Jump(ref vars) => [INFO] [stderr] 224 | code.push(jmp_call!(vars.len(), 0, pvs)), [INFO] [stderr] 225 | QueryTerm::Clause(_, ref ct, ref terms, true) => [INFO] [stderr] 226 | code.push(call_clause_by_default!(ct.clone(), terms.len(), pvs)), [INFO] [stderr] 227 | QueryTerm::Clause(_, ref ct, ref terms, false) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:239:17 [INFO] [stderr] | [INFO] [stderr] 239 | / match ctrl { [INFO] [stderr] 240 | | &mut ControlInstruction::CallClause(_, _, _, ref mut last_call, _) => [INFO] [stderr] 241 | | *last_call = true, [INFO] [stderr] 242 | | &mut ControlInstruction::JmpBy(_, _, _, ref mut last_call) => [INFO] [stderr] ... | [INFO] [stderr] 245 | | _ => dealloc_index += 1 [INFO] [stderr] 246 | | }, [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] 239 | match *ctrl { [INFO] [stderr] 240 | ControlInstruction::CallClause(_, _, _, ref mut last_call, _) => [INFO] [stderr] 241 | *last_call = true, [INFO] [stderr] 242 | ControlInstruction::JmpBy(_, _, _, ref mut last_call) => [INFO] [stderr] 243 | *last_call = true, [INFO] [stderr] 244 | ControlInstruction::Proceed => {}, [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/prolog/codegen.rs:255:66 [INFO] [stderr] | [INFO] [stderr] 255 | fn compile_inlined(&mut self, ct: &InlinedClauseType, terms: &'a Vec>, [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/codegen.rs:259:9 [INFO] [stderr] | [INFO] [stderr] 259 | / match ct { [INFO] [stderr] 260 | | &InlinedClauseType::CompareNumber(cmp, ..) => { [INFO] [stderr] 261 | | let (mut lcode, at_1) = self.call_arith_eval(terms[0].as_ref(), 1)?; [INFO] [stderr] 262 | | let (mut rcode, at_2) = self.call_arith_eval(terms[1].as_ref(), 2)?; [INFO] [stderr] ... | [INFO] [stderr] 396 | | } [INFO] [stderr] 397 | | } [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] 259 | match *ct { [INFO] [stderr] 260 | InlinedClauseType::CompareNumber(cmp, ..) => { [INFO] [stderr] 261 | let (mut lcode, at_1) = self.call_arith_eval(terms[0].as_ref(), 1)?; [INFO] [stderr] 262 | let (mut rcode, at_2) = self.call_arith_eval(terms[1].as_ref(), 2)?; [INFO] [stderr] 263 | [INFO] [stderr] 264 | code.append(&mut lcode); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:272:17 [INFO] [stderr] | [INFO] [stderr] 272 | / match terms[0].as_ref() { [INFO] [stderr] 273 | | &Term::Constant(_, Constant::Char(_)) [INFO] [stderr] 274 | | | &Term::Constant(_, Constant::Atom(..)) => { [INFO] [stderr] 275 | | code.push(succeed!()); [INFO] [stderr] ... | [INFO] [stderr] 283 | | } [INFO] [stderr] 284 | | }, [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] 272 | match *terms[0].as_ref() { [INFO] [stderr] 273 | Term::Constant(_, Constant::Char(_)) [INFO] [stderr] 274 | | Term::Constant(_, Constant::Atom(..)) => { [INFO] [stderr] 275 | code.push(succeed!()); [INFO] [stderr] 276 | }, [INFO] [stderr] 277 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:286:17 [INFO] [stderr] | [INFO] [stderr] 286 | / match terms[0].as_ref() { [INFO] [stderr] 287 | | &Term::AnonVar | &Term::Clause(..) | &Term::Cons(..) => { [INFO] [stderr] 288 | | code.push(fail!()); [INFO] [stderr] 289 | | }, [INFO] [stderr] ... | [INFO] [stderr] 296 | | } [INFO] [stderr] 297 | | }, [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] 286 | match *terms[0].as_ref() { [INFO] [stderr] 287 | Term::AnonVar | Term::Clause(..) | Term::Cons(..) => { [INFO] [stderr] 288 | code.push(fail!()); [INFO] [stderr] 289 | }, [INFO] [stderr] 290 | Term::Constant(..) => { [INFO] [stderr] 291 | code.push(succeed!()); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:299:17 [INFO] [stderr] | [INFO] [stderr] 299 | / match terms[0].as_ref() { [INFO] [stderr] 300 | | &Term::Clause(..) | &Term::Cons(..) => { [INFO] [stderr] 301 | | code.push(succeed!()); [INFO] [stderr] 302 | | }, [INFO] [stderr] ... | [INFO] [stderr] 309 | | } [INFO] [stderr] 310 | | }, [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] 299 | match *terms[0].as_ref() { [INFO] [stderr] 300 | Term::Clause(..) | Term::Cons(..) => { [INFO] [stderr] 301 | code.push(succeed!()); [INFO] [stderr] 302 | }, [INFO] [stderr] 303 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:312:17 [INFO] [stderr] | [INFO] [stderr] 312 | / match terms[0].as_ref() { [INFO] [stderr] 313 | | &Term::Constant(_, Constant::Number(Number::Rational(_))) => { [INFO] [stderr] 314 | | code.push(succeed!()); [INFO] [stderr] 315 | | }, [INFO] [stderr] ... | [INFO] [stderr] 322 | | } [INFO] [stderr] 323 | | }, [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] 312 | match *terms[0].as_ref() { [INFO] [stderr] 313 | Term::Constant(_, Constant::Number(Number::Rational(_))) => { [INFO] [stderr] 314 | code.push(succeed!()); [INFO] [stderr] 315 | }, [INFO] [stderr] 316 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:325:17 [INFO] [stderr] | [INFO] [stderr] 325 | / match terms[0].as_ref() { [INFO] [stderr] 326 | | &Term::Constant(_, Constant::Number(Number::Float(_))) => { [INFO] [stderr] 327 | | code.push(succeed!()); [INFO] [stderr] 328 | | }, [INFO] [stderr] ... | [INFO] [stderr] 335 | | } [INFO] [stderr] 336 | | }, [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] 325 | match *terms[0].as_ref() { [INFO] [stderr] 326 | Term::Constant(_, Constant::Number(Number::Float(_))) => { [INFO] [stderr] 327 | code.push(succeed!()); [INFO] [stderr] 328 | }, [INFO] [stderr] 329 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:338:17 [INFO] [stderr] | [INFO] [stderr] 338 | / match terms[0].as_ref() { [INFO] [stderr] 339 | | &Term::Constant(_, Constant::String(_)) => { [INFO] [stderr] 340 | | code.push(succeed!()); [INFO] [stderr] 341 | | }, [INFO] [stderr] ... | [INFO] [stderr] 348 | | } [INFO] [stderr] 349 | | }, [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] 338 | match *terms[0].as_ref() { [INFO] [stderr] 339 | Term::Constant(_, Constant::String(_)) => { [INFO] [stderr] 340 | code.push(succeed!()); [INFO] [stderr] 341 | }, [INFO] [stderr] 342 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:351:17 [INFO] [stderr] | [INFO] [stderr] 351 | / match terms[0].as_ref() { [INFO] [stderr] 352 | | &Term::AnonVar => { [INFO] [stderr] 353 | | code.push(fail!()); [INFO] [stderr] 354 | | }, [INFO] [stderr] ... | [INFO] [stderr] 361 | | } [INFO] [stderr] 362 | | }, [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] 351 | match *terms[0].as_ref() { [INFO] [stderr] 352 | Term::AnonVar => { [INFO] [stderr] 353 | code.push(fail!()); [INFO] [stderr] 354 | }, [INFO] [stderr] 355 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:364:17 [INFO] [stderr] | [INFO] [stderr] 364 | / match terms[0].as_ref() { [INFO] [stderr] 365 | | &Term::Constant(_, Constant::Number(Number::Integer(_))) => { [INFO] [stderr] 366 | | code.push(succeed!()); [INFO] [stderr] 367 | | }, [INFO] [stderr] ... | [INFO] [stderr] 374 | | }, [INFO] [stderr] 375 | | }, [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] 364 | match *terms[0].as_ref() { [INFO] [stderr] 365 | Term::Constant(_, Constant::Number(Number::Integer(_))) => { [INFO] [stderr] 366 | code.push(succeed!()); [INFO] [stderr] 367 | }, [INFO] [stderr] 368 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:377:17 [INFO] [stderr] | [INFO] [stderr] 377 | / match terms[0].as_ref() { [INFO] [stderr] 378 | | &Term::Constant(..) | &Term::Clause(..) | &Term::Cons(..) => { [INFO] [stderr] 379 | | code.push(fail!()); [INFO] [stderr] 380 | | }, [INFO] [stderr] ... | [INFO] [stderr] 387 | | } [INFO] [stderr] 388 | | }, [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] 377 | match *terms[0].as_ref() { [INFO] [stderr] 378 | Term::Constant(..) | Term::Clause(..) | Term::Cons(..) => { [INFO] [stderr] 379 | code.push(fail!()); [INFO] [stderr] 380 | }, [INFO] [stderr] 381 | Term::AnonVar => { [INFO] [stderr] 382 | code.push(succeed!()); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:390:17 [INFO] [stderr] | [INFO] [stderr] 390 | / match terms[0].as_ref() { [INFO] [stderr] 391 | | &Term::Var(ref vr, ref name) => { [INFO] [stderr] 392 | | let r = self.mark_non_callable(name.clone(), 1, term_loc, vr, code); [INFO] [stderr] 393 | | code.push(is_partial_string!(r)); [INFO] [stderr] 394 | | }, [INFO] [stderr] 395 | | _ => code.push(fail!()) [INFO] [stderr] 396 | | } [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] 390 | match *terms[0].as_ref() { [INFO] [stderr] 391 | Term::Var(ref vr, ref name) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:420:17 [INFO] [stderr] | [INFO] [stderr] 420 | / match *term { [INFO] [stderr] 421 | | &QueryTerm::GetLevelAndUnify(ref cell, ref var) => { [INFO] [stderr] 422 | | let mut target = Vec::new(); [INFO] [stderr] 423 | | [INFO] [stderr] ... | [INFO] [stderr] 493 | | }, [INFO] [stderr] 494 | | }; [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] 420 | match *(*term) { [INFO] [stderr] 421 | QueryTerm::GetLevelAndUnify(ref cell, ref var) => { [INFO] [stderr] 422 | let mut target = Vec::new(); [INFO] [stderr] 423 | [INFO] [stderr] 424 | self.marker.reset_arg(1); [INFO] [stderr] 425 | self.marker.mark_var(var.clone(), Level::Shallow, cell, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:449:25 [INFO] [stderr] | [INFO] [stderr] 449 | / match terms[0].as_ref() { [INFO] [stderr] 450 | | &Term::Var(ref vr, ref name) => { [INFO] [stderr] 451 | | let mut target = Vec::new(); [INFO] [stderr] 452 | | [INFO] [stderr] ... | [INFO] [stderr] 480 | | } [INFO] [stderr] 481 | | } [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] 449 | match *terms[0].as_ref() { [INFO] [stderr] 450 | Term::Var(ref vr, ref name) => { [INFO] [stderr] 451 | let mut target = Vec::new(); [INFO] [stderr] 452 | [INFO] [stderr] 453 | self.marker.reset_arg(2); [INFO] [stderr] 454 | self.marker.mark_var(name.clone(), Level::Shallow, vr, [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:519:9 [INFO] [stderr] | [INFO] [stderr] 519 | / match toc { [INFO] [stderr] 520 | | &QueryTerm::BlockedCut | &QueryTerm::UnblockedCut(..) => code.push(proceed!()), [INFO] [stderr] 521 | | &QueryTerm::Clause(_, ClauseType::Inlined(..), ..) => code.push(proceed!()), [INFO] [stderr] 522 | | _ => {} [INFO] [stderr] 523 | | }; [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] 519 | match *toc { [INFO] [stderr] 520 | QueryTerm::BlockedCut | QueryTerm::UnblockedCut(..) => code.push(proceed!()), [INFO] [stderr] 521 | QueryTerm::Clause(_, ClauseType::Inlined(..), ..) => code.push(proceed!()), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:555:25 [INFO] [stderr] | [INFO] [stderr] 555 | let index = if let &Line::Control(_) = code.last().unwrap() { [INFO] [stderr] | _________________________^ [INFO] [stderr] 556 | | code.len() - 2 [INFO] [stderr] 557 | | } else { [INFO] [stderr] 558 | | code.len() - 1 [INFO] [stderr] 559 | | }; [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] 555 | let index = if let Line::Control(_) = *code.last().unwrap() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:561:13 [INFO] [stderr] | [INFO] [stderr] 561 | / if let &mut Line::Query(ref mut query) = &mut code[index] { [INFO] [stderr] 562 | | let head_iter = FactIterator::from_rule_head_clause(args); [INFO] [stderr] 563 | | conjunct_info.perm_vs.mark_unsafe_vars_in_rule(head_iter, query); [INFO] [stderr] 564 | | } [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] 561 | if let Line::Query(ref mut query) = *(&mut code[index]) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:580:13 [INFO] [stderr] | [INFO] [stderr] 580 | / match fact_instr { [INFO] [stderr] 581 | | &mut FactInstruction::UnifyValue(reg) => [INFO] [stderr] 582 | | if let Some(found) = unsafe_vars.get_mut(®) { [INFO] [stderr] 583 | | if !*found { [INFO] [stderr] ... | [INFO] [stderr] 593 | | _ => {} [INFO] [stderr] 594 | | }; [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] 580 | match *fact_instr { [INFO] [stderr] 581 | FactInstruction::UnifyValue(reg) => [INFO] [stderr] 582 | if let Some(found) = unsafe_vars.get_mut(®) { [INFO] [stderr] 583 | if !*found { [INFO] [stderr] 584 | *found = true; [INFO] [stderr] 585 | *fact_instr = FactInstruction::UnifyLocalValue(reg); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:610:9 [INFO] [stderr] | [INFO] [stderr] 610 | / if let &Term::Clause(_, _, ref args, _) = term { [INFO] [stderr] 611 | | self.marker.reset_at_head(args); [INFO] [stderr] 612 | | [INFO] [stderr] 613 | | let iter = FactInstruction::iter(term); [INFO] [stderr] ... | [INFO] [stderr] 620 | | } [INFO] [stderr] 621 | | } [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] 610 | if let Term::Clause(_, _, ref args, _) = *term { [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/prolog/codegen.rs:642:44 [INFO] [stderr] | [INFO] [stderr] 642 | pub fn compile_query(&mut self, query: &'a Vec) -> Result [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[QueryTerm]` [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/prolog/codegen.rs:654:25 [INFO] [stderr] | [INFO] [stderr] 654 | let index = if let &Line::Control(_) = code.last().unwrap() { [INFO] [stderr] | _________________________^ [INFO] [stderr] 655 | | code.len() - 2 [INFO] [stderr] 656 | | } else { [INFO] [stderr] 657 | | code.len() - 1 [INFO] [stderr] 658 | | }; [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] 654 | let index = if let Line::Control(_) = *code.last().unwrap() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/codegen.rs:660:13 [INFO] [stderr] | [INFO] [stderr] 660 | / if let &mut Line::Query(ref mut query) = &mut code[index] { [INFO] [stderr] 661 | | conjunct_info.perm_vs.mark_unsafe_vars_in_query(query); [INFO] [stderr] 662 | | } [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] 660 | if let Line::Query(ref mut query) = *(&mut code[index]) { [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/prolog/codegen.rs:672:33 [INFO] [stderr] | [INFO] [stderr] 672 | fn split_predicate(clauses: &Vec) -> Vec<(usize, usize)> [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateClause]` [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/prolog/codegen.rs:725:35 [INFO] [stderr] | [INFO] [stderr] 725 | let mut clause_code = match clause { [INFO] [stderr] | ___________________________________^ [INFO] [stderr] 726 | | &PredicateClause::Fact(ref fact) => [INFO] [stderr] 727 | | self.compile_fact(fact), [INFO] [stderr] 728 | | &PredicateClause::Rule(ref rule) => [INFO] [stderr] 729 | | try!(self.compile_rule(rule)) [INFO] [stderr] 730 | | }; [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] 725 | let mut clause_code = match *clause { [INFO] [stderr] 726 | PredicateClause::Fact(ref fact) => [INFO] [stderr] 727 | self.compile_fact(fact), [INFO] [stderr] 728 | PredicateClause::Rule(ref rule) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: called `map(f)` on an Option value where `f` is a unit closure [INFO] [stderr] --> src/prolog/codegen.rs:742:13 [INFO] [stderr] | [INFO] [stderr] 742 | clause.first_arg().map(|arg| { [INFO] [stderr] | _____________^ [INFO] [stderr] | |_____________| [INFO] [stderr] | || [INFO] [stderr] 743 | || let index = code_body.len(); [INFO] [stderr] 744 | || code_offsets.index_term(arg, index); [INFO] [stderr] 745 | || }); [INFO] [stderr] | ||______________^- help: try this: `if let Some(arg) = clause.first_arg() { ... }` [INFO] [stderr] | |_______________| [INFO] [stderr] | [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::option_map_unit_fn)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn [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/prolog/codegen.rs:756:58 [INFO] [stderr] | [INFO] [stderr] 756 | pub fn compile_predicate<'b: 'a>(&mut self, clauses: &'b Vec) [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: change this to: `&[PredicateClause]` [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/prolog/debray_allocator.rs:21:46 [INFO] [stderr] | [INFO] [stderr] 21 | fn is_curr_arg_distinct_from(&self, var: &Var) -> 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: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/debray_allocator.rs:28:45 [INFO] [stderr] | [INFO] [stderr] 28 | fn occurs_shallowly_in_head(&self, var: &Var, r: usize) -> 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/prolog/debray_allocator.rs:30:9 [INFO] [stderr] | [INFO] [stderr] 30 | / match self.bindings.get(var).unwrap() { [INFO] [stderr] 31 | | &VarData::Temp(_, _, ref tvd) => [INFO] [stderr] 32 | | tvd.use_set.contains(&(GenContext::Head, r)), [INFO] [stderr] 33 | | _ => false [INFO] [stderr] 34 | | } [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] 30 | match *self.bindings.get(var).unwrap() { [INFO] [stderr] 31 | VarData::Temp(_, _, ref tvd) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise [INFO] [stderr] --> src/prolog/debray_allocator.rs:30:15 [INFO] [stderr] | [INFO] [stderr] 30 | match self.bindings.get(var).unwrap() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&self.bindings[var]` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/debray_allocator.rs:42:34 [INFO] [stderr] | [INFO] [stderr] 42 | fn alloc_with_cr(&self, var: &Var) -> usize [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/prolog/debray_allocator.rs:69:34 [INFO] [stderr] | [INFO] [stderr] 69 | fn alloc_with_ca(&self, var: &Var) -> usize [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: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise [INFO] [stderr] --> src/prolog/debray_allocator.rs:111:27 [INFO] [stderr] | [INFO] [stderr] 111 | let tvd = self.bindings.get(t_var).unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&self.bindings[t_var]` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/debray_allocator.rs:112:17 [INFO] [stderr] | [INFO] [stderr] 112 | / if let &VarData::Temp(_, _, ref tvd) = tvd { [INFO] [stderr] 113 | | if !tvd.use_set.contains(&(GenContext::Last(chunk_num), k)) { [INFO] [stderr] 114 | | return Some((t_var.clone(), self.alloc_with_ca(t_var))); [INFO] [stderr] 115 | | } [INFO] [stderr] 116 | | } [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] 112 | if let VarData::Temp(_, _, ref tvd) = *tvd { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/debray_allocator.rs:127:9 [INFO] [stderr] | [INFO] [stderr] 127 | / match self.alloc_in_last_goal_hint(chunk_num) { [INFO] [stderr] 128 | | Some((var, r)) => { [INFO] [stderr] 129 | | let k = self.arg_c; [INFO] [stderr] 130 | | [INFO] [stderr] ... | [INFO] [stderr] 143 | | _ => {} [INFO] [stderr] 144 | | }; [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 127 | if let Some((var, r)) = self.alloc_in_last_goal_hint(chunk_num) { [INFO] [stderr] 128 | let k = self.arg_c; [INFO] [stderr] 129 | [INFO] [stderr] 130 | if r != k { [INFO] [stderr] 131 | let r = RegType::Temp(r); [INFO] [stderr] 132 | [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/debray_allocator.rs:147:53 [INFO] [stderr] | [INFO] [stderr] 147 | fn alloc_reg_to_var<'a, Target>(&mut self, var: &Var, lvl: Level, term_loc: GenContext, [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/prolog/debray_allocator.rs:188:29 [INFO] [stderr] | [INFO] [stderr] 188 | fn in_place(&self, var: &Var, term_loc: GenContext, r: RegType, k: usize) -> 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/prolog/debray_allocator.rs:192:18 [INFO] [stderr] | [INFO] [stderr] 192 | _ => match self.bindings().get(var).unwrap() { [INFO] [stderr] | __________________^ [INFO] [stderr] 193 | | &VarData::Temp(_, o, _) if r.reg_num() == k => o == k, [INFO] [stderr] 194 | | _ => false [INFO] [stderr] 195 | | } [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] 192 | _ => match *self.bindings().get(var).unwrap() { [INFO] [stderr] 193 | VarData::Temp(_, o, _) if r.reg_num() == k => o == k, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/debray_allocator.rs:358:13 [INFO] [stderr] | [INFO] [stderr] 358 | / if let &Term::Var(_, ref var) = arg.as_ref() { [INFO] [stderr] 359 | | let r = self.get(var.clone()); [INFO] [stderr] 360 | | [INFO] [stderr] 361 | | if !r.is_perm() && r.reg_num() == 0 { [INFO] [stderr] ... | [INFO] [stderr] 365 | | } [INFO] [stderr] 366 | | } [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] 358 | if let Term::Var(_, ref var) = *arg.as_ref() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:41:13 [INFO] [stderr] | [INFO] [stderr] 41 | / if let &mut VarStatus::Temp(_, ref mut var_data) = var_status { [INFO] [stderr] 42 | | let mut use_set = OccurrenceSet::new(); [INFO] [stderr] 43 | | [INFO] [stderr] 44 | | swap(&mut var_data.use_set, &mut use_set); [INFO] [stderr] 45 | | use_sets.insert((*var).clone(), use_set); [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 | if let VarStatus::Temp(_, ref mut var_data) = *var_status { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:54:25 [INFO] [stderr] | [INFO] [stderr] 54 | / if let &mut VarStatus::Temp(cn_t, ref mut t_data) = var_status { [INFO] [stderr] 55 | | if cn_u == cn_t && *u != ***t { [INFO] [stderr] 56 | | if !t_data.uses_reg(reg) { [INFO] [stderr] 57 | | t_data.no_use_set.insert(reg); [INFO] [stderr] 58 | | } [INFO] [stderr] 59 | | } [INFO] [stderr] 60 | | } [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] 54 | if let VarStatus::Temp(cn_t, ref mut t_data) = *var_status { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/fixtures.rs:66:13 [INFO] [stderr] | [INFO] [stderr] 66 | / match self.get_mut(u).unwrap() { [INFO] [stderr] 67 | | &mut (VarStatus::Temp(_, ref mut u_data), _) => { [INFO] [stderr] 68 | | u_data.use_set = use_set; [INFO] [stderr] 69 | | u_data.populate_conflict_set(); [INFO] [stderr] 70 | | }, [INFO] [stderr] 71 | | _ => {} [INFO] [stderr] 72 | | }; [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 66 | if let &mut (VarStatus::Temp(_, ref mut u_data), _) = self.get_mut(u).unwrap() { [INFO] [stderr] 67 | u_data.use_set = use_set; [INFO] [stderr] 68 | u_data.populate_conflict_set(); [INFO] [stderr] 69 | }; [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:66:13 [INFO] [stderr] | [INFO] [stderr] 66 | / match self.get_mut(u).unwrap() { [INFO] [stderr] 67 | | &mut (VarStatus::Temp(_, ref mut u_data), _) => { [INFO] [stderr] 68 | | u_data.use_set = use_set; [INFO] [stderr] 69 | | u_data.populate_conflict_set(); [INFO] [stderr] 70 | | }, [INFO] [stderr] 71 | | _ => {} [INFO] [stderr] 72 | | }; [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] 66 | match *self.get_mut(u).unwrap() { [INFO] [stderr] 67 | (VarStatus::Temp(_, ref mut u_data), _) => { [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:102:13 [INFO] [stderr] | [INFO] [stderr] 102 | / if let &VarStatus::Perm(i) = var_status { [INFO] [stderr] 103 | | if i > index { [INFO] [stderr] 104 | | var_count += 1; [INFO] [stderr] 105 | | } [INFO] [stderr] 106 | | } [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] 102 | if let VarStatus::Perm(i) = *var_status { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/fixtures.rs:119:13 [INFO] [stderr] | [INFO] [stderr] 119 | / if let &TermRef::Var(lvl, cell, ref var) = &term_ref { [INFO] [stderr] 120 | | let mut status = self.0.remove(var) [INFO] [stderr] 121 | | .unwrap_or((VarStatus::Temp(chunk_num, TempVarData::new(lt_arity)), [INFO] [stderr] 122 | | Vec::new())); [INFO] [stderr] ... | [INFO] [stderr] 135 | | self.0.insert(var.clone(), status); [INFO] [stderr] 136 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 119 | if let TermRef::Var(lvl, cell, ref var) = term_ref { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/fixtures.rs:160:17 [INFO] [stderr] | [INFO] [stderr] 160 | / match &v.0 { [INFO] [stderr] 161 | | &VarStatus::Perm(i) => Some((i, &v.1)), [INFO] [stderr] 162 | | _ => None [INFO] [stderr] 163 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 160 | match v.0 { [INFO] [stderr] 161 | VarStatus::Perm(i) => Some((i, &v.1)), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/fixtures.rs:181:13 [INFO] [stderr] | [INFO] [stderr] 181 | / match query_instr { [INFO] [stderr] 182 | | &mut QueryInstruction::PutValue(RegType::Perm(i), arg) => [INFO] [stderr] 183 | | if let Some(found) = unsafe_vars.get_mut(&RegType::Perm(i)) { [INFO] [stderr] 184 | | if !*found { [INFO] [stderr] ... | [INFO] [stderr] 201 | | _ => {} [INFO] [stderr] 202 | | }; [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] 181 | match *query_instr { [INFO] [stderr] 182 | QueryInstruction::PutValue(RegType::Perm(i), arg) => [INFO] [stderr] 183 | if let Some(found) = unsafe_vars.get_mut(&RegType::Perm(i)) { [INFO] [stderr] 184 | if !*found { [INFO] [stderr] 185 | *found = true; [INFO] [stderr] 186 | *query_instr = QueryInstruction::PutUnsafeValue(i, arg); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/fixtures.rs:208:13 [INFO] [stderr] | [INFO] [stderr] 208 | / match cb.first() { [INFO] [stderr] 209 | | Some(index) => { [INFO] [stderr] 210 | | unsafe_vars.insert(index.get().norm(), false); [INFO] [stderr] 211 | | }, [INFO] [stderr] 212 | | None => {} [INFO] [stderr] 213 | | }; [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 208 | if let Some(index) = cb.first() { [INFO] [stderr] 209 | unsafe_vars.insert(index.get().norm(), false); [INFO] [stderr] 210 | }; [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/fixtures.rs:220:13 [INFO] [stderr] | [INFO] [stderr] 220 | / match term_ref { [INFO] [stderr] 221 | | TermRef::Var(Level::Shallow, cell, _) => { [INFO] [stderr] 222 | | unsafe_vars.remove(&cell.get().norm()); [INFO] [stderr] 223 | | }, [INFO] [stderr] 224 | | _ => {} [INFO] [stderr] 225 | | }; [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_match [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 220 | if let TermRef::Var(Level::Shallow, cell, _) = term_ref { [INFO] [stderr] 221 | unsafe_vars.remove(&cell.get().norm()); [INFO] [stderr] 222 | }; [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/heap_iter.rs:24:9 [INFO] [stderr] | [INFO] [stderr] 24 | / match &self.machine_st.heap[h] { [INFO] [stderr] 25 | | &HeapCellValue::NamedStr(arity, _, _) => { [INFO] [stderr] 26 | | for idx in (1 .. arity + 1).rev() { [INFO] [stderr] 27 | | self.state_stack.push(Addr::HeapCell(h + idx)); [INFO] [stderr] ... | [INFO] [stderr] 33 | | self.follow(a.clone()) [INFO] [stderr] 34 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 24 | match self.machine_st.heap[h] { [INFO] [stderr] 25 | HeapCellValue::NamedStr(arity, _, _) => { [INFO] [stderr] 26 | for idx in (1 .. arity + 1).rev() { [INFO] [stderr] 27 | self.state_stack.push(Addr::HeapCell(h + idx)); [INFO] [stderr] 28 | } [INFO] [stderr] 29 | [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/prolog/heap_iter.rs:26:28 [INFO] [stderr] | [INFO] [stderr] 26 | for idx in (1 .. arity + 1).rev() { [INFO] [stderr] | ^^^^^^^^^^^^^^^^ help: use: `(1..=arity)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> src/prolog/heap_iter.rs:131:5 [INFO] [stderr] | [INFO] [stderr] 131 | / pub fn pre_order_iter<'a>(&'a self, a: Addr) -> HCPreOrderIterator<'a> { [INFO] [stderr] 132 | | HCPreOrderIterator::new(self, a) [INFO] [stderr] 133 | | } [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: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration) [INFO] [stderr] --> src/prolog/heap_iter.rs:135:5 [INFO] [stderr] | [INFO] [stderr] 135 | / pub fn post_order_iter<'a>(&'a self, a: Addr) -> HCPostOrderIterator<'a> { [INFO] [stderr] 136 | | HCPostOrderIterator::new(HCPreOrderIterator::new(self, a)) [INFO] [stderr] 137 | | } [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: called `map(f)` on an Option value where `f` is a unit closure [INFO] [stderr] --> src/prolog/indexing.rs:30:9 [INFO] [stderr] | [INFO] [stderr] 30 | / prelude.last_mut().map(|instr| { [INFO] [stderr] 31 | | match instr { [INFO] [stderr] 32 | | &mut IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] 33 | | *instr = IndexedChoiceInstruction::Trust(i), [INFO] [stderr] 34 | | _ => {} [INFO] [stderr] 35 | | }; [INFO] [stderr] 36 | | }); [INFO] [stderr] | |__________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 30 | if let Some(instr) = prelude.last_mut() { match instr { [INFO] [stderr] 31 | &mut IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] 32 | *instr = IndexedChoiceInstruction::Trust(i), [INFO] [stderr] 33 | _ => {} [INFO] [stderr] 34 | }; } [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/indexing.rs:31:13 [INFO] [stderr] | [INFO] [stderr] 31 | / match instr { [INFO] [stderr] 32 | | &mut IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] 33 | | *instr = IndexedChoiceInstruction::Trust(i), [INFO] [stderr] 34 | | _ => {} [INFO] [stderr] 35 | | }; [INFO] [stderr] | |_____________^ help: try this: `if let &mut IndexedChoiceInstruction::Retry(i) = instr { *instr = IndexedChoiceInstruction::Trust(i) }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/indexing.rs:31:13 [INFO] [stderr] | [INFO] [stderr] 31 | / match instr { [INFO] [stderr] 32 | | &mut IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] 33 | | *instr = IndexedChoiceInstruction::Trust(i), [INFO] [stderr] 34 | | _ => {} [INFO] [stderr] 35 | | }; [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 *instr { [INFO] [stderr] 32 | IndexedChoiceInstruction::Retry(i) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/indexing.rs:49:9 [INFO] [stderr] | [INFO] [stderr] 49 | / match first_arg { [INFO] [stderr] 50 | | &Term::Clause(_, ref name, ref terms, _) => { [INFO] [stderr] 51 | | let code = self.structures.entry((name.clone(), terms.len())) [INFO] [stderr] 52 | | .or_insert(Vec::new()); [INFO] [stderr] ... | [INFO] [stderr] 73 | | _ => {} [INFO] [stderr] 74 | | }; [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] 49 | match *first_arg { [INFO] [stderr] 50 | Term::Clause(_, ref name, ref terms, _) => { [INFO] [stderr] 51 | let code = self.structures.entry((name.clone(), terms.len())) [INFO] [stderr] 52 | .or_insert(Vec::new()); [INFO] [stderr] 53 | [INFO] [stderr] 54 | let is_initial_index = code.is_empty(); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: use of `or_insert` followed by a function call [INFO] [stderr] --> src/prolog/indexing.rs:52:33 [INFO] [stderr] | [INFO] [stderr] 52 | .or_insert(Vec::new()); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)` [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 `or_insert` followed by a function call [INFO] [stderr] --> src/prolog/indexing.rs:68:33 [INFO] [stderr] | [INFO] [stderr] 68 | .or_insert(Vec::new()); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)` [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: redundant closure found [INFO] [stderr] --> src/prolog/indexing.rs:87:53 [INFO] [stderr] | [INFO] [stderr] 87 | prelude.extend(code.into_iter().map(|code| Line::from(code))); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ help: remove closure as shown: `Line::from` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::redundant_closure)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure [INFO] [stderr] [INFO] [stderr] warning: called `map(f)` on an Option value where `f` is a unit closure [INFO] [stderr] --> src/prolog/indexing.rs:89:17 [INFO] [stderr] | [INFO] [stderr] 89 | code.first().map(|i| { [INFO] [stderr] | _________________^ [INFO] [stderr] | |_________________| [INFO] [stderr] | || [INFO] [stderr] 90 | || index_locs.insert(key, IntIndex::External(i.offset())); [INFO] [stderr] 91 | || }); [INFO] [stderr] | ||__________________^- help: try this: `if let Some(i) = code.first() { index_locs.insert(key, IntIndex::External(i.offset())); }` [INFO] [stderr] | |___________________| [INFO] [stderr] | [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn [INFO] [stderr] [INFO] [stderr] warning: redundant closure found [INFO] [stderr] --> src/prolog/indexing.rs:179:50 [INFO] [stderr] | [INFO] [stderr] 179 | prelude.extend(lists.into_iter().map(|i| Line::from(i))); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ help: remove closure as shown: `Line::from` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/indexing.rs:238:13 [INFO] [stderr] | [INFO] [stderr] 238 | / match line { [INFO] [stderr] 239 | | &mut Line::IndexedChoice(IndexedChoiceInstruction::Try(ref mut i)) [INFO] [stderr] 240 | | | &mut Line::IndexedChoice(IndexedChoiceInstruction::Retry(ref mut i)) [INFO] [stderr] 241 | | | &mut Line::IndexedChoice(IndexedChoiceInstruction::Trust(ref mut i)) => [INFO] [stderr] 242 | | *i += prelude_length - index, [INFO] [stderr] 243 | | _ => {} [INFO] [stderr] 244 | | } [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] 238 | match *line { [INFO] [stderr] 239 | Line::IndexedChoice(IndexedChoiceInstruction::Try(ref mut i)) [INFO] [stderr] 240 | | Line::IndexedChoice(IndexedChoiceInstruction::Retry(ref mut i)) [INFO] [stderr] 241 | | Line::IndexedChoice(IndexedChoiceInstruction::Trust(ref mut i)) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: writing `&String` instead of `&str` involves a new object where a slice will do. [INFO] [stderr] --> src/prolog/write.rs:12:20 [INFO] [stderr] | [INFO] [stderr] 12 | fn error_string(e: &String) -> 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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:18:9 [INFO] [stderr] | [INFO] [stderr] 18 | / match self { [INFO] [stderr] 19 | | &IndexPtr::Module => [INFO] [stderr] 20 | | write!(f, ""), [INFO] [stderr] 21 | | &IndexPtr::Undefined => [INFO] [stderr] ... | [INFO] [stderr] 24 | | write!(f, "{}", i) [INFO] [stderr] 25 | | } [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] 18 | match *self { [INFO] [stderr] 19 | IndexPtr::Module => [INFO] [stderr] 20 | write!(f, ""), [INFO] [stderr] 21 | IndexPtr::Undefined => [INFO] [stderr] 22 | write!(f, "undefined"), [INFO] [stderr] 23 | IndexPtr::Index(i) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:37:9 [INFO] [stderr] | [INFO] [stderr] 37 | / match self { [INFO] [stderr] 38 | | &FactInstruction::GetConstant(lvl, ref constant, ref r) => [INFO] [stderr] 39 | | write!(f, "get_constant {}, {}{}", constant, lvl, r.reg_num()), [INFO] [stderr] 40 | | &FactInstruction::GetList(lvl, ref r) => [INFO] [stderr] ... | [INFO] [stderr] 57 | | write!(f, "unify_void {}", n) [INFO] [stderr] 58 | | } [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] 37 | match *self { [INFO] [stderr] 38 | FactInstruction::GetConstant(lvl, ref constant, ref r) => [INFO] [stderr] 39 | write!(f, "get_constant {}, {}{}", constant, lvl, r.reg_num()), [INFO] [stderr] 40 | FactInstruction::GetList(lvl, ref r) => [INFO] [stderr] 41 | write!(f, "get_list {}{}", lvl, r.reg_num()), [INFO] [stderr] 42 | FactInstruction::GetStructure(ref ct, ref arity, ref r) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:64:9 [INFO] [stderr] | [INFO] [stderr] 64 | / match self { [INFO] [stderr] 65 | | &QueryInstruction::GetVariable(ref x, ref a) => [INFO] [stderr] 66 | | write!(f, "query:get_variable {}, A{}", x, a), [INFO] [stderr] 67 | | &QueryInstruction::PutConstant(lvl, ref constant, ref r) => [INFO] [stderr] ... | [INFO] [stderr] 88 | | write!(f, "set_void {}", n) [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] 64 | match *self { [INFO] [stderr] 65 | QueryInstruction::GetVariable(ref x, ref a) => [INFO] [stderr] 66 | write!(f, "query:get_variable {}, A{}", x, a), [INFO] [stderr] 67 | QueryInstruction::PutConstant(lvl, ref constant, ref r) => [INFO] [stderr] 68 | write!(f, "put_constant {}, {}{}", constant, lvl, r.reg_num()), [INFO] [stderr] 69 | QueryInstruction::PutList(lvl, ref r) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:95:9 [INFO] [stderr] | [INFO] [stderr] 95 | / match self { [INFO] [stderr] 96 | | &CompareNumberQT::GreaterThan => write!(f, ">"), [INFO] [stderr] 97 | | &CompareNumberQT::GreaterThanOrEqual => write!(f, ">="), [INFO] [stderr] 98 | | &CompareNumberQT::LessThan => write!(f, "<"), [INFO] [stderr] ... | [INFO] [stderr] 101 | | &CompareNumberQT::Equal => write!(f, "=:="), [INFO] [stderr] 102 | | } [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] 95 | match *self { [INFO] [stderr] 96 | CompareNumberQT::GreaterThan => write!(f, ">"), [INFO] [stderr] 97 | CompareNumberQT::GreaterThanOrEqual => write!(f, ">="), [INFO] [stderr] 98 | CompareNumberQT::LessThan => write!(f, "<"), [INFO] [stderr] 99 | CompareNumberQT::LessThanOrEqual => write!(f, "<="), [INFO] [stderr] 100 | CompareNumberQT::NotEqual => write!(f, "=\\="), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:108:9 [INFO] [stderr] | [INFO] [stderr] 108 | / match self { [INFO] [stderr] 109 | | &CompareTermQT::GreaterThan => write!(f, "@>"), [INFO] [stderr] 110 | | &CompareTermQT::GreaterThanOrEqual => write!(f, "@>="), [INFO] [stderr] 111 | | &CompareTermQT::LessThan => write!(f, "@<"), [INFO] [stderr] ... | [INFO] [stderr] 114 | | &CompareTermQT::Equal => write!(f, "=@="), [INFO] [stderr] 115 | | } [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] 108 | match *self { [INFO] [stderr] 109 | CompareTermQT::GreaterThan => write!(f, "@>"), [INFO] [stderr] 110 | CompareTermQT::GreaterThanOrEqual => write!(f, "@>="), [INFO] [stderr] 111 | CompareTermQT::LessThan => write!(f, "@<"), [INFO] [stderr] 112 | CompareTermQT::LessThanOrEqual => write!(f, "@<="), [INFO] [stderr] 113 | CompareTermQT::NotEqual => write!(f, "\\=@="), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:133:9 [INFO] [stderr] | [INFO] [stderr] 133 | / match self { [INFO] [stderr] 134 | | &ControlInstruction::Allocate(num_cells) => [INFO] [stderr] 135 | | write!(f, "allocate {}", num_cells), [INFO] [stderr] 136 | | &ControlInstruction::CallClause(ref ct, arity, pvs, true, true) => [INFO] [stderr] ... | [INFO] [stderr] 151 | | write!(f, "proceed"), [INFO] [stderr] 152 | | } [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] 133 | match *self { [INFO] [stderr] 134 | ControlInstruction::Allocate(num_cells) => [INFO] [stderr] 135 | write!(f, "allocate {}", num_cells), [INFO] [stderr] 136 | ControlInstruction::CallClause(ref ct, arity, pvs, true, true) => [INFO] [stderr] 137 | write!(f, "call_with_default_policy {}/{}, {}", ct, arity, pvs), [INFO] [stderr] 138 | ControlInstruction::CallClause(ref ct, arity, pvs, false, true) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:158:9 [INFO] [stderr] | [INFO] [stderr] 158 | / match self { [INFO] [stderr] 159 | | &IndexedChoiceInstruction::Try(offset) => [INFO] [stderr] 160 | | write!(f, "try {}", offset), [INFO] [stderr] 161 | | &IndexedChoiceInstruction::Retry(offset) => [INFO] [stderr] ... | [INFO] [stderr] 164 | | write!(f, "trust {}", offset) [INFO] [stderr] 165 | | } [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] 158 | match *self { [INFO] [stderr] 159 | IndexedChoiceInstruction::Try(offset) => [INFO] [stderr] 160 | write!(f, "try {}", offset), [INFO] [stderr] 161 | IndexedChoiceInstruction::Retry(offset) => [INFO] [stderr] 162 | write!(f, "retry {}", offset), [INFO] [stderr] 163 | IndexedChoiceInstruction::Trust(offset) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:171:9 [INFO] [stderr] | [INFO] [stderr] 171 | / match self { [INFO] [stderr] 172 | | &ChoiceInstruction::TryMeElse(offset) => [INFO] [stderr] 173 | | write!(f, "try_me_else {}", offset), [INFO] [stderr] 174 | | &ChoiceInstruction::DefaultRetryMeElse(offset) => [INFO] [stderr] ... | [INFO] [stderr] 181 | | write!(f, "trust_me") [INFO] [stderr] 182 | | } [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] 171 | match *self { [INFO] [stderr] 172 | ChoiceInstruction::TryMeElse(offset) => [INFO] [stderr] 173 | write!(f, "try_me_else {}", offset), [INFO] [stderr] 174 | ChoiceInstruction::DefaultRetryMeElse(offset) => [INFO] [stderr] 175 | write!(f, "retry_me_else_by_default {}", offset), [INFO] [stderr] 176 | ChoiceInstruction::RetryMeElse(offset) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:188:9 [INFO] [stderr] | [INFO] [stderr] 188 | / match self { [INFO] [stderr] 189 | | &IndexingInstruction::SwitchOnTerm(v, c, l, s) => [INFO] [stderr] 190 | | write!(f, "switch_on_term {}, {}, {}, {}", v, c, l, s), [INFO] [stderr] 191 | | &IndexingInstruction::SwitchOnConstant(num_cs, _) => [INFO] [stderr] ... | [INFO] [stderr] 194 | | write!(f, "switch_on_structure {}", num_ss) [INFO] [stderr] 195 | | } [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] 188 | match *self { [INFO] [stderr] 189 | IndexingInstruction::SwitchOnTerm(v, c, l, s) => [INFO] [stderr] 190 | write!(f, "switch_on_term {}, {}, {}, {}", v, c, l, s), [INFO] [stderr] 191 | IndexingInstruction::SwitchOnConstant(num_cs, _) => [INFO] [stderr] 192 | write!(f, "switch_on_constant {}", num_cs), [INFO] [stderr] 193 | IndexingInstruction::SwitchOnStructure(num_ss, _) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:201:9 [INFO] [stderr] | [INFO] [stderr] 201 | / match self { [INFO] [stderr] 202 | | &SessionError::CannotOverwriteBuiltIn(ref msg) => [INFO] [stderr] 203 | | write!(f, "cannot overwrite {}", msg), [INFO] [stderr] 204 | | &SessionError::CannotOverwriteImport(ref msg) => [INFO] [stderr] ... | [INFO] [stderr] 214 | | &SessionError::UserPrompt => write!(f, "enter predicate at [user] prompt") [INFO] [stderr] 215 | | } [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] 201 | match *self { [INFO] [stderr] 202 | SessionError::CannotOverwriteBuiltIn(ref msg) => [INFO] [stderr] 203 | write!(f, "cannot overwrite {}", msg), [INFO] [stderr] 204 | SessionError::CannotOverwriteImport(ref msg) => [INFO] [stderr] 205 | write!(f, "cannot overwrite import {}", msg), [INFO] [stderr] 206 | SessionError::ModuleNotFound => write!(f, "module not found."), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:221:9 [INFO] [stderr] | [INFO] [stderr] 221 | / match self { [INFO] [stderr] 222 | | &ArithmeticTerm::Reg(r) => write!(f, "{}", r), [INFO] [stderr] 223 | | &ArithmeticTerm::Interm(i) => write!(f, "@{}", i), [INFO] [stderr] 224 | | &ArithmeticTerm::Number(ref n) => write!(f, "{}", n), [INFO] [stderr] 225 | | } [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] 221 | match *self { [INFO] [stderr] 222 | ArithmeticTerm::Reg(r) => write!(f, "{}", r), [INFO] [stderr] 223 | ArithmeticTerm::Interm(i) => write!(f, "@{}", i), [INFO] [stderr] 224 | ArithmeticTerm::Number(ref n) => write!(f, "{}", n), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:231:9 [INFO] [stderr] | [INFO] [stderr] 231 | / match self { [INFO] [stderr] 232 | | &ArithmeticInstruction::Abs(ref a1, ref t) => [INFO] [stderr] 233 | | write!(f, "abs {}, @{}", a1, t), [INFO] [stderr] 234 | | &ArithmeticInstruction::Add(ref a1, ref a2, ref t) => [INFO] [stderr] ... | [INFO] [stderr] 265 | | write!(f, "neg {}, @{}", a, t) [INFO] [stderr] 266 | | } [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] 231 | match *self { [INFO] [stderr] 232 | ArithmeticInstruction::Abs(ref a1, ref t) => [INFO] [stderr] 233 | write!(f, "abs {}, @{}", a1, t), [INFO] [stderr] 234 | ArithmeticInstruction::Add(ref a1, ref a2, ref t) => [INFO] [stderr] 235 | write!(f, "add {}, {}, @{}", a1, a2, t), [INFO] [stderr] 236 | ArithmeticInstruction::Sub(ref a1, ref a2, ref t) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:272:9 [INFO] [stderr] | [INFO] [stderr] 272 | / match self { [INFO] [stderr] 273 | | &CutInstruction::Cut(r) => [INFO] [stderr] 274 | | write!(f, "cut {}", r), [INFO] [stderr] 275 | | &CutInstruction::NeckCut => [INFO] [stderr] ... | [INFO] [stderr] 280 | | write!(f, "get_level_and_unify {}", r) [INFO] [stderr] 281 | | } [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] 272 | match *self { [INFO] [stderr] 273 | CutInstruction::Cut(r) => [INFO] [stderr] 274 | write!(f, "cut {}", r), [INFO] [stderr] 275 | CutInstruction::NeckCut => [INFO] [stderr] 276 | write!(f, "neck_cut"), [INFO] [stderr] 277 | CutInstruction::GetLevel(r) => [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/write.rs:287:9 [INFO] [stderr] | [INFO] [stderr] 287 | / match self { [INFO] [stderr] 288 | | &Level::Root | &Level::Shallow => write!(f, "A"), [INFO] [stderr] 289 | | &Level::Deep => write!(f, "X") [INFO] [stderr] 290 | | } [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] 287 | match *self { [INFO] [stderr] 288 | Level::Root | Level::Shallow => write!(f, "A"), [INFO] [stderr] 289 | Level::Deep => write!(f, "X") [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/write.rs:336:21 [INFO] [stderr] | [INFO] [stderr] 336 | / if let &EvalSession::Error(SessionError::QueryFailure) = &result [INFO] [stderr] 337 | | { [INFO] [stderr] 338 | | write!(stdout, "false.\n\r").unwrap(); [INFO] [stderr] 339 | | stdout.flush().unwrap(); [INFO] [stderr] 340 | | return; [INFO] [stderr] 341 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 336 | if let EvalSession::Error(SessionError::QueryFailure) = result [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/write.rs:343:21 [INFO] [stderr] | [INFO] [stderr] 343 | / if let &EvalSession::Error(SessionError::QueryFailureWithException(ref e)) = &result [INFO] [stderr] 344 | | { [INFO] [stderr] 345 | | write!(stdout, "{}\n\r", error_string(e)).unwrap(); [INFO] [stderr] 346 | | stdout.flush().unwrap(); [INFO] [stderr] 347 | | return; [INFO] [stderr] 348 | | } [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: try [INFO] [stderr] | [INFO] [stderr] 343 | if let EvalSession::Error(SessionError::QueryFailureWithException(ref e)) = result [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: use of `write!(stdout(), ...).unwrap()`. Consider using `print!` instead [INFO] [stderr] --> src/prolog/write.rs:354:13 [INFO] [stderr] | [INFO] [stderr] 354 | write!(stdout(), ".\n").unwrap(); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::explicit_write)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#explicit_write [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/prolog/iterators.rs:40:37 [INFO] [stderr] | [INFO] [stderr] 40 | fn from_rule_head_clause(terms: &'a Vec>) -> Self { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/iterators.rs:49:21 [INFO] [stderr] | [INFO] [stderr] 49 | let state = match term { [INFO] [stderr] | _____________________^ [INFO] [stderr] 50 | | &Term::AnonVar => [INFO] [stderr] 51 | | return QueryIterator { state_stack: vec![] }, [INFO] [stderr] 52 | | &Term::Clause(ref r, ref name, ref terms, fixity) => [INFO] [stderr] ... | [INFO] [stderr] 61 | | TermIterState::Var(Level::Root, cell, (*var).clone()) [INFO] [stderr] 62 | | }; [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] 49 | let state = match *term { [INFO] [stderr] 50 | Term::AnonVar => [INFO] [stderr] 51 | return QueryIterator { state_stack: vec![] }, [INFO] [stderr] 52 | Term::Clause(ref r, ref name, ref terms, fixity) => [INFO] [stderr] 53 | TermIterState::Clause(Level::Root, 0, r, [INFO] [stderr] 54 | ClauseType::from(name.clone(), terms.len(), fixity), [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/iterators.rs:68:9 [INFO] [stderr] | [INFO] [stderr] 68 | / match term { [INFO] [stderr] 69 | | &QueryTerm::Clause(ref cell, ClauseType::CallN, ref terms, _) => { [INFO] [stderr] 70 | | let state = TermIterState::Clause(Level::Root, 1, cell, ClauseType::CallN, terms); [INFO] [stderr] 71 | | QueryIterator { state_stack: vec![state] } [INFO] [stderr] ... | [INFO] [stderr] 93 | | QueryIterator { state_stack: vec![] }, [INFO] [stderr] 94 | | } [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] 68 | match *term { [INFO] [stderr] 69 | QueryTerm::Clause(ref cell, ClauseType::CallN, ref terms, _) => { [INFO] [stderr] 70 | let state = TermIterState::Clause(Level::Root, 1, cell, ClauseType::CallN, terms); [INFO] [stderr] 71 | QueryIterator { state_stack: vec![state] } [INFO] [stderr] 72 | }, [INFO] [stderr] 73 | QueryTerm::Clause(ref cell, ref ct, ref terms, _) => { [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/prolog/iterators.rs:154:41 [INFO] [stderr] | [INFO] [stderr] 154 | pub fn from_rule_head_clause(terms: &'a Vec>) -> Self { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[Box]` [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/prolog/iterators.rs:163:22 [INFO] [stderr] | [INFO] [stderr] 163 | let states = match term { [INFO] [stderr] | ______________________^ [INFO] [stderr] 164 | | &Term::AnonVar => [INFO] [stderr] 165 | | vec![TermIterState::AnonVar(Level::Root)], [INFO] [stderr] 166 | | &Term::Clause(ref cell, ref name, ref terms, fixity) => { [INFO] [stderr] ... | [INFO] [stderr] 175 | | vec![TermIterState::Var(Level::Root, cell, var.clone())] [INFO] [stderr] 176 | | }; [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] 163 | let states = match *term { [INFO] [stderr] 164 | Term::AnonVar => [INFO] [stderr] 165 | vec![TermIterState::AnonVar(Level::Root)], [INFO] [stderr] 166 | Term::Clause(ref cell, ref name, ref terms, fixity) => { [INFO] [stderr] 167 | let ct = ClauseType::from(name.clone(), terms.len(), fixity); [INFO] [stderr] 168 | vec![TermIterState::Clause(Level::Root, 0, cell, ct, terms)] [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/prolog/iterators.rs:231:1 [INFO] [stderr] | [INFO] [stderr] 231 | / pub fn query_term_post_order_iter<'a>(query_term: &'a QueryTerm) -> QueryIterator<'a> { [INFO] [stderr] 232 | | QueryIterator::new(query_term) [INFO] [stderr] 233 | | } [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 don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/iterators.rs:237:9 [INFO] [stderr] | [INFO] [stderr] 237 | / match self { [INFO] [stderr] 238 | | &ChunkedTerm::BodyTerm(ref qt) => [INFO] [stderr] 239 | | QueryIterator::new(qt), [INFO] [stderr] 240 | | &ChunkedTerm::HeadClause(_, terms) => [INFO] [stderr] 241 | | QueryIterator::from_rule_head_clause(terms) [INFO] [stderr] 242 | | } [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] 237 | match *self { [INFO] [stderr] 238 | ChunkedTerm::BodyTerm(ref qt) => [INFO] [stderr] 239 | QueryIterator::new(qt), [INFO] [stderr] 240 | ChunkedTerm::HeadClause(_, terms) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/iterators.rs:248:9 [INFO] [stderr] | [INFO] [stderr] 248 | / if let &Term::Var(_, ref var) = term { [INFO] [stderr] 249 | | if var.as_str() == "!" { [INFO] [stderr] 250 | | return true; [INFO] [stderr] 251 | | } [INFO] [stderr] 252 | | } [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] 248 | if let Term::Var(_, ref var) = *term { [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/prolog/iterators.rs:299:55 [INFO] [stderr] | [INFO] [stderr] 299 | pub fn from_rule_body(p1: &'a QueryTerm, clauses: &'a Vec) -> Self [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^ help: change this to: `&[QueryTerm]` [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: this function has too many arguments (10/7) [INFO] [stderr] --> src/prolog/or_stack.rs:20:5 [INFO] [stderr] | [INFO] [stderr] 20 | / fn new(global_index: usize, [INFO] [stderr] 21 | | e: usize, [INFO] [stderr] 22 | | cp: LocalCodePtr, [INFO] [stderr] 23 | | b: usize, [INFO] [stderr] ... | [INFO] [stderr] 43 | | } [INFO] [stderr] 44 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stderr] [INFO] [stderr] warning: this function has too many arguments (11/7) [INFO] [stderr] --> src/prolog/or_stack.rs:58:5 [INFO] [stderr] | [INFO] [stderr] 58 | / pub fn push(&mut self, [INFO] [stderr] 59 | | global_index: usize, [INFO] [stderr] 60 | | e: usize, [INFO] [stderr] 61 | | cp: LocalCodePtr, [INFO] [stderr] ... | [INFO] [stderr] 70 | | self.0.push(Frame::new(global_index, e, cp, b, bp, tr, pstr_tr, h, b0, n)); [INFO] [stderr] 71 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments [INFO] [stderr] [INFO] [stderr] warning: length comparison to zero [INFO] [stderr] --> src/prolog/heap_print.rs:68:12 [INFO] [stderr] | [INFO] [stderr] 68 | if self.contents.len() != 0 { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `!self.contents.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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/heap_print.rs:92:19 [INFO] [stderr] | [INFO] [stderr] 92 | arity == 1 && if let &ClauseType::Named(ref name, _) = ct { [INFO] [stderr] | ___________________^ [INFO] [stderr] 93 | | name.as_str() == "$VAR" [INFO] [stderr] 94 | | } else { [INFO] [stderr] 95 | | false [INFO] [stderr] 96 | | } [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] 92 | arity == 1 && if let ClauseType::Named(ref name, _) = *ct { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ [INFO] [stderr] [INFO] [stderr] error: this `if` has identical blocks [INFO] [stderr] --> src/prolog/heap_print.rs:160:48 [INFO] [stderr] | [INFO] [stderr] 160 | } else if capital_letter_char!(ac) { [INFO] [stderr] | ________________________________________________^ [INFO] [stderr] 161 | | alpha_numeric_char!(oc) [INFO] [stderr] 162 | | } else { [INFO] [stderr] | |_____________^ [INFO] [stderr] | [INFO] [stderr] note: same as this [INFO] [stderr] --> src/prolog/heap_print.rs:158:52 [INFO] [stderr] | [INFO] [stderr] 158 | } else if variable_indicator_char!(ac) { [INFO] [stderr] | ____________________________________________________^ [INFO] [stderr] 159 | | alpha_numeric_char!(oc) [INFO] [stderr] 160 | | } else if capital_letter_char!(ac) { [INFO] [stderr] | |_____________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 39 [INFO] [stderr] --> src/prolog/heap_print.rs:178:1 [INFO] [stderr] | [INFO] [stderr] 178 | / fn non_quoted_graphic_token>(mut iter: Iter, c: char) -> bool { [INFO] [stderr] 179 | | if c == '/' { [INFO] [stderr] 180 | | return match iter.next() { [INFO] [stderr] 181 | | None => true, [INFO] [stderr] ... | [INFO] [stderr] 200 | | } [INFO] [stderr] 201 | | } [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: this boolean expression can be simplified [INFO] [stderr] --> src/prolog/heap_print.rs:214:13 [INFO] [stderr] | [INFO] [stderr] 214 | !iter.next().is_none() [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^ help: try: `iter.next().is_some()` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::nonminimal_bool)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool [INFO] [stderr] [INFO] [stderr] error: this `if` has identical blocks [INFO] [stderr] --> src/prolog/heap_print.rs:211:32 [INFO] [stderr] | [INFO] [stderr] 211 | } else if cut_char!(c) { [INFO] [stderr] | ________________________________^ [INFO] [stderr] 212 | | iter.next().is_none() [INFO] [stderr] 213 | | } else if solo_char!(c) { [INFO] [stderr] | |_________^ [INFO] [stderr] | [INFO] [stderr] note: same as this [INFO] [stderr] --> src/prolog/heap_print.rs:209:38 [INFO] [stderr] | [INFO] [stderr] 209 | } else if semicolon_char!(c) { [INFO] [stderr] | ______________________________________^ [INFO] [stderr] 210 | | iter.next().is_none() [INFO] [stderr] 211 | | } else if cut_char!(c) { [INFO] [stderr] | |_________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/heap_print.rs:231:5 [INFO] [stderr] | [INFO] [stderr] 231 | / match op { [INFO] [stderr] 232 | | &Some(DirectedOp::Left(ref lop)) if continues_with_append(lop.as_str(), atom) => [INFO] [stderr] 233 | | Some(DirectedOp::Left(lop.clone())), [INFO] [stderr] 234 | | &Some(DirectedOp::Right(ref rop)) if continues_with_append(atom, rop.as_str()) => [INFO] [stderr] ... | [INFO] [stderr] 237 | | None [INFO] [stderr] 238 | | } [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] 231 | match *op { [INFO] [stderr] 232 | Some(DirectedOp::Left(ref lop)) if continues_with_append(lop.as_str(), atom) => [INFO] [stderr] 233 | Some(DirectedOp::Left(lop.clone())), [INFO] [stderr] 234 | Some(DirectedOp::Right(ref rop)) if continues_with_append(atom, rop.as_str()) => [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: needlessly taken reference of both operands [INFO] [stderr] --> src/prolog/heap_print.rs:446:20 [INFO] [stderr] | [INFO] [stderr] 446 | if &fl == &OrderedFloat(0f64) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#op_ref [INFO] [stderr] help: use the values directly [INFO] [stderr] | [INFO] [stderr] 446 | if fl == OrderedFloat(0f64) { [INFO] [stderr] | ^^ ^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/targets.rs:58:9 [INFO] [stderr] | [INFO] [stderr] 58 | / match self { [INFO] [stderr] 59 | | &FactInstruction::UnifyVoid(_) => true, [INFO] [stderr] 60 | | _ => false [INFO] [stderr] 61 | | } [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] 58 | match *self { [INFO] [stderr] 59 | FactInstruction::UnifyVoid(_) => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/targets.rs:65:9 [INFO] [stderr] | [INFO] [stderr] 65 | / match self { [INFO] [stderr] 66 | | &mut FactInstruction::UnifyVoid(ref mut incr) => *incr += 1, [INFO] [stderr] 67 | | _ => {} [INFO] [stderr] 68 | | } [INFO] [stderr] | |_________^ help: try this: `if let &mut FactInstruction::UnifyVoid(ref mut incr) = self { *incr += 1 }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/targets.rs:65:9 [INFO] [stderr] | [INFO] [stderr] 65 | / match self { [INFO] [stderr] 66 | | &mut FactInstruction::UnifyVoid(ref mut incr) => *incr += 1, [INFO] [stderr] 67 | | _ => {} [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] 65 | match *self { [INFO] [stderr] 66 | FactInstruction::UnifyVoid(ref mut incr) => *incr += 1, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/targets.rs:125:9 [INFO] [stderr] | [INFO] [stderr] 125 | / match self { [INFO] [stderr] 126 | | &QueryInstruction::SetVoid(_) => true, [INFO] [stderr] 127 | | _ => false [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] 125 | match *self { [INFO] [stderr] 126 | QueryInstruction::SetVoid(_) => true, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you seem to be trying to use match for destructuring a single pattern. Consider using `if let` [INFO] [stderr] --> src/prolog/targets.rs:132:9 [INFO] [stderr] | [INFO] [stderr] 132 | / match self { [INFO] [stderr] 133 | | &mut QueryInstruction::SetVoid(ref mut incr) => *incr += 1, [INFO] [stderr] 134 | | _ => {} [INFO] [stderr] 135 | | } [INFO] [stderr] | |_________^ help: try this: `if let &mut QueryInstruction::SetVoid(ref mut incr) = self { *incr += 1 }` [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: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/targets.rs:132:9 [INFO] [stderr] | [INFO] [stderr] 132 | / match self { [INFO] [stderr] 133 | | &mut QueryInstruction::SetVoid(ref mut incr) => *incr += 1, [INFO] [stderr] 134 | | _ => {} [INFO] [stderr] 135 | | } [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] 132 | match *self { [INFO] [stderr] 133 | QueryInstruction::SetVoid(ref mut incr) => *incr += 1, [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to all patterns [INFO] [stderr] --> src/prolog/read.rs:18:9 [INFO] [stderr] | [INFO] [stderr] 18 | / match self { [INFO] [stderr] 19 | | &TermRef::AnonVar(_) | &TermRef::Var(..) => Addr::HeapCell(h), [INFO] [stderr] 20 | | &TermRef::Cons(..) => Addr::HeapCell(h), [INFO] [stderr] 21 | | &TermRef::Constant(_, _, c) => Addr::Con(c.clone()), [INFO] [stderr] 22 | | &TermRef::Clause(..) => Addr::Str(h), [INFO] [stderr] 23 | | } [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] 18 | match *self { [INFO] [stderr] 19 | TermRef::AnonVar(_) | TermRef::Var(..) => Addr::HeapCell(h), [INFO] [stderr] 20 | TermRef::Cons(..) => Addr::HeapCell(h), [INFO] [stderr] 21 | TermRef::Constant(_, _, c) => Addr::Con(c.clone()), [INFO] [stderr] 22 | TermRef::Clause(..) => Addr::Str(h), [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you don't need to add `&` to both the expression and the patterns [INFO] [stderr] --> src/prolog/read.rs:94:9 [INFO] [stderr] | [INFO] [stderr] 94 | / match &term { [INFO] [stderr] 95 | | &TermRef::Cons(lvl, ..) => { [INFO] [stderr] 96 | | queue.push_back((2, h+1)); [INFO] [stderr] 97 | | machine_st.heap.push(HeapCellValue::Addr(Addr::Lis(h+1))); [INFO] [stderr] ... | [INFO] [stderr] 148 | | _ => {} [INFO] [stderr] 149 | | }; [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: try [INFO] [stderr] | [INFO] [stderr] 94 | match term { [INFO] [stderr] 95 | TermRef::Cons(lvl, ..) => { [INFO] [stderr] 96 | queue.push_back((2, h+1)); [INFO] [stderr] 97 | machine_st.heap.push(HeapCellValue::Addr(Addr::Lis(h+1))); [INFO] [stderr] 98 | [INFO] [stderr] 99 | push_stub_addr(machine_st); [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 39 [INFO] [stderr] --> src/tests.rs:303:1 [INFO] [stderr] | [INFO] [stderr] 303 | / fn test_queries_on_predicates() { [INFO] [stderr] 304 | | let mut wam = Machine::new(); [INFO] [stderr] 305 | | [INFO] [stderr] 306 | | submit(&mut wam, "p(X, a). p(b, X)."); [INFO] [stderr] ... | [INFO] [stderr] 482 | | ["X = f(c)"]]); [INFO] [stderr] 483 | | } [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: the function has a cyclomatic complexity of 29 [INFO] [stderr] --> src/tests.rs:550:1 [INFO] [stderr] | [INFO] [stderr] 550 | / fn test_queries_on_lists() [INFO] [stderr] 551 | | { [INFO] [stderr] 552 | | let mut wam = Machine::new(); [INFO] [stderr] 553 | | [INFO] [stderr] ... | [INFO] [stderr] 603 | | assert_prolog_failure!(&mut wam, "?- member([X, Y, Z], [a, [b, c], [b, b], [Z, x], [d, f]])."); [INFO] [stderr] 604 | | } [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: the function has a cyclomatic complexity of 77 [INFO] [stderr] --> src/tests.rs:699:1 [INFO] [stderr] | [INFO] [stderr] 699 | / fn test_queries_on_call_n() [INFO] [stderr] 700 | | { [INFO] [stderr] 701 | | let mut wam = Machine::new(); [INFO] [stderr] 702 | | [INFO] [stderr] ... | [INFO] [stderr] 949 | | ["X = y"]]); [INFO] [stderr] 950 | | } [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: the function has a cyclomatic complexity of 75 [INFO] [stderr] --> src/tests.rs:953:1 [INFO] [stderr] | [INFO] [stderr] 953 | / fn test_queries_on_arithmetic() [INFO] [stderr] 954 | | { [INFO] [stderr] 955 | | let mut wam = Machine::new(); [INFO] [stderr] 956 | | [INFO] [stderr] ... | [INFO] [stderr] 1102 | | [["E = evaluation_error(zero_divisor)"]]); [INFO] [stderr] 1103 | | } [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: the function has a cyclomatic complexity of 33 [INFO] [stderr] --> src/tests.rs:1211:1 [INFO] [stderr] | [INFO] [stderr] 1211 | / fn test_queries_on_skip_max_list() { [INFO] [stderr] 1212 | | let mut wam = Machine::new(); [INFO] [stderr] 1213 | | [INFO] [stderr] 1214 | | // test on proper and empty lists. [INFO] [stderr] ... | [INFO] [stderr] 1283 | | [["Xs = non_list", "N = 0"]]); [INFO] [stderr] 1284 | | } [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: the function has a cyclomatic complexity of 27 [INFO] [stderr] --> src/tests.rs:1287:1 [INFO] [stderr] | [INFO] [stderr] 1287 | / fn test_queries_on_conditionals() [INFO] [stderr] 1288 | | { [INFO] [stderr] 1289 | | let mut wam = Machine::new(); [INFO] [stderr] 1290 | | [INFO] [stderr] ... | [INFO] [stderr] 1347 | | [["X = a"], ["X = b"]]); [INFO] [stderr] 1348 | | } [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: calling `as_bytes()` on a string literal [INFO] [stderr] --> src/tests.rs:1357:35 [INFO] [stderr] | [INFO] [stderr] 1357 | compile_user_module(&mut wam, " [INFO] [stderr] | ___________________________________^ [INFO] [stderr] 1358 | | :- module(my_lists, [local_member/2, reverse/2]). [INFO] [stderr] 1359 | | :- use_module(library(lists), [member/2]). [INFO] [stderr] 1360 | | [INFO] [stderr] ... | [INFO] [stderr] 1363 | | reverse(Xs, Ys) :- lists:reverse(Xs, Ys). [INFO] [stderr] 1364 | | ".as_bytes()); [INFO] [stderr] | |____________^ [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] help: consider using a byte string literal instead [INFO] [stderr] | [INFO] [stderr] 1357 | compile_user_module(&mut wam, b" [INFO] [stderr] 1358 | :- module(my_lists, [local_member/2, reverse/2]). [INFO] [stderr] 1359 | :- use_module(library(lists), [member/2]). [INFO] [stderr] 1360 | [INFO] [stderr] 1361 | local_member(X, Xs) :- member(X, Xs). [INFO] [stderr] 1362 | [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: calling `as_bytes()` on a string literal [INFO] [stderr] --> src/tests.rs:1369:35 [INFO] [stderr] | [INFO] [stderr] 1369 | compile_user_module(&mut wam, " [INFO] [stderr] | ___________________________________^ [INFO] [stderr] 1370 | | :- module(my_lists_2, [local_member/2]). [INFO] [stderr] 1371 | | :- use_module(library(my_lists), [local_member/2]). [INFO] [stderr] 1372 | | ".as_bytes()); [INFO] [stderr] | |____________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#string_lit_as_bytes [INFO] [stderr] help: consider using a byte string literal instead [INFO] [stderr] | [INFO] [stderr] 1369 | compile_user_module(&mut wam, b" [INFO] [stderr] 1370 | :- module(my_lists_2, [local_member/2]). [INFO] [stderr] 1371 | :- use_module(library(my_lists), [local_member/2]). [INFO] [stderr] 1372 | "); [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 194 [INFO] [stderr] --> src/tests.rs:1391:1 [INFO] [stderr] | [INFO] [stderr] 1391 | / fn test_queries_on_builtins() [INFO] [stderr] 1392 | | { [INFO] [stderr] 1393 | | let mut wam = Machine::new(); [INFO] [stderr] 1394 | | [INFO] [stderr] ... | [INFO] [stderr] 1684 | | [["X = a:-b,c"]]); [INFO] [stderr] 1685 | | } [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: calling `as_bytes()` on a string literal [INFO] [stderr] --> src/tests.rs:1876:5 [INFO] [stderr] | [INFO] [stderr] 1876 | / " ability(destroy, X) --> destroy(X). [INFO] [stderr] 1877 | | destroy(X) --> [destroy], target(X). [INFO] [stderr] 1878 | | target(X) --> [target], permanent(X). [INFO] [stderr] 1879 | | permanent(X) --> [creature], creature(X). [INFO] [stderr] ... | [INFO] [stderr] 1889 | | sorcery('Duress') --> []. [INFO] [stderr] 1890 | | instant('Lightning Bolt') --> [].".as_bytes()); [INFO] [stderr] | |___________________________________________________^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#string_lit_as_bytes [INFO] [stderr] help: consider using a byte string literal instead [INFO] [stderr] | [INFO] [stderr] 1876 | b" ability(destroy, X) --> destroy(X). [INFO] [stderr] 1877 | destroy(X) --> [destroy], target(X). [INFO] [stderr] 1878 | target(X) --> [target], permanent(X). [INFO] [stderr] 1879 | permanent(X) --> [creature], creature(X). [INFO] [stderr] 1880 | permanent(X) --> [artifact], artifact(X). [INFO] [stderr] 1881 | permanent(X) --> [land], land(X). [INFO] [stderr] ... [INFO] [stderr] [INFO] [stderr] warning: the function has a cyclomatic complexity of 74 [INFO] [stderr] --> src/tests.rs:1899:1 [INFO] [stderr] | [INFO] [stderr] 1899 | / fn test_queries_on_string_lists() [INFO] [stderr] 1900 | | { [INFO] [stderr] 1901 | | let mut wam = Machine::new(); [INFO] [stderr] 1902 | | [INFO] [stderr] ... | [INFO] [stderr] 2088 | | [["X = [b, c | _]", "Y = [c | _]"]]); [INFO] [stderr] 2089 | | } [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] error: aborting due to 3 previous errors [INFO] [stderr] [INFO] [stderr] error: Could not compile `rusty-wam`. [INFO] [stderr] [INFO] [stderr] To learn more, run the command again with --verbose. [INFO] running `"docker" "inspect" "2e7cb173d45722313f29266dc4ba99c24af9029495998039e005a15693d9a943"` [INFO] running `"docker" "rm" "-f" "2e7cb173d45722313f29266dc4ba99c24af9029495998039e005a15693d9a943"` [INFO] [stdout] 2e7cb173d45722313f29266dc4ba99c24af9029495998039e005a15693d9a943