error: defining a method called `add` on this type; consider implementing the `std::ops::Add` trait or choosing a less ambiguous name --> $DIR/methods.rs:18:5 | 18 | fn add(self, other: T) -> T { self } | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(should_implement_trait)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ error: defining a method called `drop` on this type; consider implementing the `std::ops::Drop` trait or choosing a less ambiguous name --> $DIR/methods.rs:19:5 | 19 | fn drop(&mut self) { } | ^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(should_implement_trait)] implied by #[deny(clippy)] error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name --> $DIR/methods.rs:26:17 | 26 | fn into_u16(&self) -> u16 { 0 } | ^^^^^ | = note: #[deny(wrong_self_convention)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ error: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name --> $DIR/methods.rs:28:21 | 28 | fn to_something(self) -> u32 { 0 } | ^^^^ | = note: #[deny(wrong_self_convention)] implied by #[deny(clippy)] error: methods called `new` usually take no self; consider choosing a less ambiguous name --> $DIR/methods.rs:30:12 | 30 | fn new(self) {} | ^^^^ | = note: #[deny(wrong_self_convention)] implied by #[deny(clippy)] error: methods called `new` usually return `Self` --> $DIR/methods.rs:30:5 | 30 | fn new(self) {} | ^^^^^^^^^^^^^^^ | = note: #[deny(new_ret_no_self)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ error: called `map(f).unwrap_or(a)` on an Option value. This can be done more directly by calling `map_or(a, f)` instead --> $DIR/methods.rs:99:13 | 99 | let _ = opt.map(|x| x + 1) | _____________^ 100 | | 101 | | .unwrap_or(0); // should lint even though this call is on a separate line | |____________________________^ | = note: #[deny(option_map_unwrap_or)] implied by #[deny(clippy_pedantic)] note: lint level defined here --> $DIR/methods.rs:5:17 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^^^^^^^^^^ = note: replace `map(|x| x + 1).unwrap_or(0)` with `map_or(0, |x| x + 1)` error: called `map(f).unwrap_or(a)` on an Option value. This can be done more directly by calling `map_or(a, f)` instead --> $DIR/methods.rs:103:13 | 103 | let _ = opt.map(|x| { | _____________^ 104 | | x + 1 105 | | } 106 | | ).unwrap_or(0); | |____________________________^ | = note: #[deny(option_map_unwrap_or)] implied by #[deny(clippy_pedantic)] error: called `map(f).unwrap_or(a)` on an Option value. This can be done more directly by calling `map_or(a, f)` instead --> $DIR/methods.rs:107:13 | 107 | let _ = opt.map(|x| x + 1) | _____________^ 108 | | .unwrap_or({ 109 | | 0 110 | | }); | |__________________^ | = note: #[deny(option_map_unwrap_or)] implied by #[deny(clippy_pedantic)] error: called `map(f).unwrap_or_else(g)` on an Option value. This can be done more directly by calling `map_or_else(g, f)` instead --> $DIR/methods.rs:116:13 | 116 | let _ = opt.map(|x| x + 1) | _____________^ 117 | | 118 | | .unwrap_or_else(|| 0); // should lint even though this call is on a separate line | |____________________________________^ | = note: #[deny(option_map_unwrap_or_else)] implied by #[deny(clippy_pedantic)] note: lint level defined here --> $DIR/methods.rs:5:17 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^^^^^^^^^^ = note: replace `map(|x| x + 1).unwrap_or_else(|| 0)` with `map_or_else(|| 0, |x| x + 1)` error: called `map(f).unwrap_or_else(g)` on an Option value. This can be done more directly by calling `map_or_else(g, f)` instead --> $DIR/methods.rs:120:13 | 120 | let _ = opt.map(|x| { | _____________^ 121 | | x + 1 122 | | } 123 | | ).unwrap_or_else(|| 0); | |____________________________________^ | = note: #[deny(option_map_unwrap_or_else)] implied by #[deny(clippy_pedantic)] error: called `map(f).unwrap_or_else(g)` on an Option value. This can be done more directly by calling `map_or_else(g, f)` instead --> $DIR/methods.rs:124:13 | 124 | let _ = opt.map(|x| x + 1) | _____________^ 125 | | .unwrap_or_else(|| 126 | | 0 127 | | ); | |_________________^ | = note: #[deny(option_map_unwrap_or_else)] implied by #[deny(clippy_pedantic)] error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead. --> $DIR/methods.rs:196:13 | 196 | let _ = v.iter().filter(|&x| *x < 0).next(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(filter_next)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ = note: replace `filter(|&x| *x < 0).next()` with `find(|&x| *x < 0)` error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead. --> $DIR/methods.rs:201:13 | 201 | let _ = v.iter().filter(|&x| { | _____________^ 202 | | *x < 0 203 | | } 204 | | ).next(); | |___________________________^ | = note: #[deny(filter_next)] implied by #[deny(clippy)] error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`. --> $DIR/methods.rs:216:13 | 216 | let _ = v.iter().find(|&x| *x < 0).is_some(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(search_is_some)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ = note: replace `find(|&x| *x < 0).is_some()` with `any(|&x| *x < 0)` error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`. --> $DIR/methods.rs:221:13 | 221 | let _ = v.iter().find(|&x| { | _____________^ 222 | | *x < 0 223 | | } 224 | | ).is_some(); | |______________________________^ | = note: #[deny(search_is_some)] implied by #[deny(clippy)] error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`. --> $DIR/methods.rs:227:13 | 227 | let _ = v.iter().position(|&x| x < 0).is_some(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(search_is_some)] implied by #[deny(clippy)] = note: replace `position(|&x| x < 0).is_some()` with `any(|&x| x < 0)` error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`. --> $DIR/methods.rs:232:13 | 232 | let _ = v.iter().position(|&x| { | _____________^ 233 | | x < 0 234 | | } 235 | | ).is_some(); | |______________________________^ | = note: #[deny(search_is_some)] implied by #[deny(clippy)] error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`. --> $DIR/methods.rs:238:13 | 238 | let _ = v.iter().rposition(|&x| x < 0).is_some(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(search_is_some)] implied by #[deny(clippy)] = note: replace `rposition(|&x| x < 0).is_some()` with `any(|&x| x < 0)` error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`. --> $DIR/methods.rs:243:13 | 243 | let _ = v.iter().rposition(|&x| { | _____________^ 244 | | x < 0 245 | | } 246 | | ).is_some(); | |______________________________^ | = note: #[deny(search_is_some)] implied by #[deny(clippy)] error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:278:5 | 278 | with_constructor.unwrap_or(make()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ help: try this | with_constructor.unwrap_or_else(make); error: use of `unwrap_or` followed by a call to `new` --> $DIR/methods.rs:284:5 | 284 | with_new.unwrap_or(Vec::new()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | with_new.unwrap_or_default(); error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:290:5 | 290 | with_const_args.unwrap_or(Vec::with_capacity(12)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | with_const_args.unwrap_or_else(|| Vec::with_capacity(12)); error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:296:5 | 296 | with_err.unwrap_or(make()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | with_err.unwrap_or_else(|_| make()); error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:302:5 | 302 | with_err_args.unwrap_or(Vec::with_capacity(12)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | with_err_args.unwrap_or_else(|_| Vec::with_capacity(12)); error: use of `unwrap_or` followed by a call to `default` --> $DIR/methods.rs:308:5 | 308 | with_default_trait.unwrap_or(Default::default()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | with_default_trait.unwrap_or_default(); error: use of `unwrap_or` followed by a call to `default` --> $DIR/methods.rs:314:5 | 314 | with_default_type.unwrap_or(u64::default()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | with_default_type.unwrap_or_default(); error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:320:5 | 320 | with_vec.unwrap_or(vec![]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | with_vec.unwrap_or_else(|| < [ _ ] > :: into_vec ( box [ $ ( $ x ) , * ] )); error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:326:5 | 326 | without_default.unwrap_or(Foo::new()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | without_default.unwrap_or_else(Foo::new); error: use of `or_insert` followed by a function call --> $DIR/methods.rs:332:5 | 332 | map.entry(42).or_insert(String::new()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | map.entry(42).or_insert_with(String::new); error: use of `or_insert` followed by a function call --> $DIR/methods.rs:338:5 | 338 | btree.entry(42).or_insert(String::new()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | btree.entry(42).or_insert_with(String::new); error: use of `unwrap_or` followed by a function call --> $DIR/methods.rs:344:13 | 344 | let _ = stringy.unwrap_or("".to_owned()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(or_fun_call)] implied by #[deny(clippy)] help: try this | let _ = stringy.unwrap_or_else(|| "".to_owned()); error: called `.iter().nth()` on a Vec. Calling `.get()` is both faster and more readable --> $DIR/methods.rs:358:23 | 358 | let bad_vec = some_vec.iter().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_nth)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ error: called `.iter().nth()` on a slice. Calling `.get()` is both faster and more readable --> $DIR/methods.rs:360:26 | 360 | let bad_slice = &some_vec[..].iter().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_nth)] implied by #[deny(clippy)] error: called `.iter().nth()` on a slice. Calling `.get()` is both faster and more readable --> $DIR/methods.rs:362:31 | 362 | let bad_boxed_slice = boxed_slice.iter().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_nth)] implied by #[deny(clippy)] error: called `.iter().nth()` on a VecDeque. Calling `.get()` is both faster and more readable --> $DIR/methods.rs:364:29 | 364 | let bad_vec_deque = some_vec_deque.iter().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_nth)] implied by #[deny(clippy)] error: called `.iter_mut().nth()` on a Vec. Calling `.get_mut()` is both faster and more readable --> $DIR/methods.rs:370:23 | 370 | let bad_vec = some_vec.iter_mut().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_nth)] implied by #[deny(clippy)] error: called `.iter_mut().nth()` on a slice. Calling `.get_mut()` is both faster and more readable --> $DIR/methods.rs:374:26 | 374 | let bad_slice = &some_vec[..].iter_mut().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_nth)] implied by #[deny(clippy)] error: called `.iter_mut().nth()` on a VecDeque. Calling `.get_mut()` is both faster and more readable --> $DIR/methods.rs:378:29 | 378 | let bad_vec_deque = some_vec_deque.iter_mut().nth(3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_nth)] implied by #[deny(clippy)] error: called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)` --> $DIR/methods.rs:392:13 | 392 | let _ = some_vec.iter().skip(42).next(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_skip_next)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ error: called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)` --> $DIR/methods.rs:395:13 | 395 | let _ = some_vec.iter().cycle().skip(42).next(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_skip_next)] implied by #[deny(clippy)] error: called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)` --> $DIR/methods.rs:398:13 | 398 | let _ = (1..10).skip(10).next(); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_skip_next)] implied by #[deny(clippy)] error: called `skip(x).next()` on an iterator. This is more succinctly expressed by calling `nth(x)` --> $DIR/methods.rs:401:14 | 401 | let _ = &some_vec[..].iter().skip(3).next(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_skip_next)] implied by #[deny(clippy)] error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise --> $DIR/methods.rs:429:17 | 429 | let _ = boxed_slice.get(1).unwrap(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ help: try this | let _ = &boxed_slice[1]; error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise --> $DIR/methods.rs:433:17 | 433 | let _ = some_slice.get(0).unwrap(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] help: try this | let _ = &some_slice[0]; error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise --> $DIR/methods.rs:437:17 | 437 | let _ = some_vec.get(0).unwrap(); | ^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] help: try this | let _ = &some_vec[0]; error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise --> $DIR/methods.rs:441:17 | 441 | let _ = some_vecdeque.get(0).unwrap(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] help: try this | let _ = &some_vecdeque[0]; error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise --> $DIR/methods.rs:445:17 | 445 | let _ = some_hashmap.get(&1).unwrap(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] help: try this | let _ = &some_hashmap[&1]; error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise --> $DIR/methods.rs:449:17 | 449 | let _ = some_btreemap.get(&1).unwrap(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] help: try this | let _ = &some_btreemap[&1]; error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise --> $DIR/methods.rs:458:10 | 458 | *boxed_slice.get_mut(0).unwrap() = 1; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] help: try this | *&mut boxed_slice[0] = 1; error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise --> $DIR/methods.rs:462:10 | 462 | *some_slice.get_mut(0).unwrap() = 1; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] help: try this | *&mut some_slice[0] = 1; error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise --> $DIR/methods.rs:466:10 | 466 | *some_vec.get_mut(0).unwrap() = 1; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] help: try this | *&mut some_vec[0] = 1; error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise --> $DIR/methods.rs:470:10 | 470 | *some_vecdeque.get_mut(0).unwrap() = 1; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(get_unwrap)] implied by #[deny(clippy)] help: try this | *&mut some_vecdeque[0] = 1; error: used unwrap() on an Option value. If you don't want to handle the None case gracefully, consider using expect() to provide a better panic message --> $DIR/methods.rs:488:13 | 488 | let _ = opt.unwrap(); | ^^^^^^^^^^^^ | = note: #[deny(option_unwrap_used)] implied by #[deny(clippy_pedantic)] note: lint level defined here --> $DIR/methods.rs:5:17 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^^^^^^^^^^ error: used unwrap() on a Result value. If you don't want to handle the Err case gracefully, consider using expect() to provide a better panic message --> $DIR/methods.rs:491:13 | 491 | let _ = res.unwrap(); | ^^^^^^^^^^^^ | = note: #[deny(result_unwrap_used)] implied by #[deny(clippy_pedantic)] note: lint level defined here --> $DIR/methods.rs:5:17 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^^^^^^^^^^ error: called `ok().expect()` on a Result value. You can call `expect` directly on the `Result` --> $DIR/methods.rs:493:5 | 493 | res.ok().expect("disaster!"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(ok_expect)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ error: called `ok().expect()` on a Result value. You can call `expect` directly on the `Result` --> $DIR/methods.rs:499:5 | 499 | res3.ok().expect("whoof"); | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(ok_expect)] implied by #[deny(clippy)] error: called `ok().expect()` on a Result value. You can call `expect` directly on the `Result` --> $DIR/methods.rs:501:5 | 501 | res4.ok().expect("argh"); | ^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(ok_expect)] implied by #[deny(clippy)] error: called `ok().expect()` on a Result value. You can call `expect` directly on the `Result` --> $DIR/methods.rs:503:5 | 503 | res5.ok().expect("oops"); | ^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(ok_expect)] implied by #[deny(clippy)] error: called `ok().expect()` on a Result value. You can call `expect` directly on the `Result` --> $DIR/methods.rs:505:5 | 505 | res6.ok().expect("meh"); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(ok_expect)] implied by #[deny(clippy)] error: you should use the `starts_with` method --> $DIR/methods.rs:517:5 | 517 | "".chars().next() == Some(' '); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(chars_next_cmp)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ help: like this | "".starts_with(' '); error: you should use the `starts_with` method --> $DIR/methods.rs:522:5 | 522 | Some(' ') != "".chars().next(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(chars_next_cmp)] implied by #[deny(clippy)] help: like this | !"".starts_with(' '); error: calling `.extend(_.chars())` --> $DIR/methods.rs:534:5 | 534 | s.extend(abc.chars()); | ^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(string_extend_chars)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ help: try this | s.push_str(abc); error: calling `.extend(_.chars())` --> $DIR/methods.rs:540:5 | 540 | s.extend("abc".chars()); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(string_extend_chars)] implied by #[deny(clippy)] help: try this | s.push_str("abc"); error: calling `.extend(_.chars())` --> $DIR/methods.rs:546:5 | 546 | s.extend(def.chars()); | ^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(string_extend_chars)] implied by #[deny(clippy)] help: try this | s.push_str(&def); error: using `clone` on a `Copy` type --> $DIR/methods.rs:560:5 | 560 | 42.clone(); | ^^^^^^^^^^ | = note: #[deny(clone_on_copy)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ help: try removing the `clone` call | 42; error: using `clone` on a `Copy` type --> $DIR/methods.rs:565:5 | 565 | (&42).clone(); | ^^^^^^^^^^^^^ | = note: #[deny(clone_on_copy)] implied by #[deny(clippy)] help: try dereferencing it | *(&42); error: using `clone` on a `Copy` type --> $DIR/methods.rs:571:5 | 571 | t.clone(); | ^^^^^^^^^ | = note: #[deny(clone_on_copy)] implied by #[deny(clippy)] help: try removing the `clone` call | t; error: using `clone` on a `Copy` type --> $DIR/methods.rs:574:5 | 574 | Some(t).clone(); | ^^^^^^^^^^^^^^^ | = note: #[deny(clone_on_copy)] implied by #[deny(clippy)] help: try removing the `clone` call | Some(t); error: using `clone` on a double-reference; this will copy the reference instead of cloning the inner type --> $DIR/methods.rs:582:22 | 582 | let z: &Vec<_> = y.clone(); | ^^^^^^^^^ | = note: #[deny(clone_double_ref)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ help: try dereferencing it | let z: &Vec<_> = (*y).clone(); error: single-character string constant used as pattern --> $DIR/methods.rs:590:13 | 590 | x.split("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ help: try using a char instead: | x.split('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:614:16 | 614 | x.contains("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.contains('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:618:19 | 618 | x.starts_with("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.starts_with('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:622:17 | 622 | x.ends_with("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.ends_with('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:626:12 | 626 | x.find("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.find('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:630:13 | 630 | x.rfind("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.rfind('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:634:14 | 634 | x.rsplit("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.rsplit('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:638:24 | 638 | x.split_terminator("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.split_terminator('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:642:25 | 642 | x.rsplit_terminator("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.rsplit_terminator('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:646:17 | 646 | x.splitn(0, "x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.splitn(0, 'x'); error: single-character string constant used as pattern --> $DIR/methods.rs:650:18 | 650 | x.rsplitn(0, "x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.rsplitn(0, 'x'); error: single-character string constant used as pattern --> $DIR/methods.rs:654:15 | 654 | x.matches("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.matches('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:658:16 | 658 | x.rmatches("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.rmatches('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:662:21 | 662 | x.match_indices("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.match_indices('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:666:22 | 666 | x.rmatch_indices("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.rmatch_indices('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:670:25 | 670 | x.trim_left_matches("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.trim_left_matches('x'); error: single-character string constant used as pattern --> $DIR/methods.rs:674:26 | 674 | x.trim_right_matches("x"); | ^^^ | = note: #[deny(single_char_pattern)] implied by #[deny(clippy)] help: try using a char instead: | x.trim_right_matches('x'); error: you are getting the inner pointer of a temporary `CString` --> $DIR/methods.rs:687:5 | 687 | CString::new("foo").unwrap().as_ptr(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(temporary_cstring_as_ptr)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ = note: that pointer will be invalid outside this expression help: assign the `CString` to a variable to extend its lifetime --> $DIR/methods.rs:687:5 | 687 | CString::new("foo").unwrap().as_ptr(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: called `cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable --> $DIR/methods.rs:695:27 | 695 | let v2 : Vec = v.iter().cloned().collect(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[deny(iter_cloned_collect)] implied by #[deny(clippy)] note: lint level defined here --> $DIR/methods.rs:5:9 | 5 | #![deny(clippy, clippy_pedantic)] | ^^^^^^ error: aborting due to 89 previous errors