Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Reproduce unused_qualifications lint in tests
error: unnecessary qualification
--> tests/test.rs:29:5
|
29 | async fn selfvalue(self)
| ^^^^^
|
note: the lint level is defined here
--> tests/test.rs:5:34
|
5 | #![deny(rust_2021_compatibility, unused_qualifications)]
| ^^^^^^^^^^^^^^^^^^^^^
help: remove the unnecessary path segments
|
29 | async fn selfvalue(self)
|
error: unnecessary qualification
--> tests/test.rs:35:5
|
35 | async fn selfref(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
35 | async fn selfref(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:37:5
|
37 | async fn selfmut(&mut self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
37 | async fn selfmut(&mut self) {}
|
error: unnecessary qualification
--> tests/test.rs:39:5
|
39 | async fn required() -> Self::Assoc;
| ^^^^^
|
help: remove the unnecessary path segments
|
39 | async fn required() -> Self::Assoc;
|
error: unnecessary qualification
--> tests/test.rs:41:5
|
41 | async fn elided_lifetime(_x: &str) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
41 | async fn elided_lifetime(_x: &str) {}
|
error: unnecessary qualification
--> tests/test.rs:43:5
|
43 | async fn explicit_lifetime<'a>(_x: &'a str) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
43 | async fn explicit_lifetime<'a>(_x: &'a str) {}
|
error: unnecessary qualification
--> tests/test.rs:45:5
|
45 | async fn generic_type_param<T: Send>(x: Box<T>) -> T {
| ^^^^^
|
help: remove the unnecessary path segments
|
45 | async fn generic_type_param<T: Send>(x: Box<T>) -> T {
|
error: unnecessary qualification
--> tests/test.rs:45:58
|
45 | async fn generic_type_param<T: Send>(x: Box<T>) -> T {
| __________________________________________________________^
46 | | *x
47 | | }
| |_____^
|
help: remove the unnecessary path segments
|
45 | async fn generic_type_param<T: Send>(x: Box<T>) -> T {
|
error: unnecessary qualification
--> tests/test.rs:49:5
|
49 | async fn calls(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
49 | async fn calls(&self) {
|
error: unnecessary qualification
--> tests/test.rs:55:5
|
55 | async fn calls_mut(&mut self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
55 | async fn calls_mut(&mut self) {
|
error: unnecessary qualification
--> tests/test.rs:66:5
|
66 | async fn selfvalue(self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
66 | async fn selfvalue(self) {}
|
error: unnecessary qualification
--> tests/test.rs:68:5
|
68 | async fn selfref(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
68 | async fn selfref(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:70:5
|
70 | async fn selfmut(&mut self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
70 | async fn selfmut(&mut self) {}
|
error: unnecessary qualification
--> tests/test.rs:72:5
|
72 | async fn required() -> Self::Assoc {}
| ^^^^^
|
help: remove the unnecessary path segments
|
72 | async fn required() -> Self::Assoc {}
|
error: unnecessary qualification
--> tests/test.rs:72:40
|
72 | async fn required() -> Self::Assoc {}
| ^^
|
help: remove the unnecessary path segments
|
72 | async fn required() -> Self::Assoc {}
|
error: unnecessary qualification
--> tests/test.rs:74:5
|
74 | async fn elided_lifetime(_x: &str) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
74 | async fn elided_lifetime(_x: &str) {}
|
error: unnecessary qualification
--> tests/test.rs:76:5
|
76 | async fn explicit_lifetime<'a>(_x: &'a str) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
76 | async fn explicit_lifetime<'a>(_x: &'a str) {}
|
error: unnecessary qualification
--> tests/test.rs:78:5
|
78 | async fn generic_type_param<T: Send>(x: Box<T>) -> T {
| ^^^^^
|
help: remove the unnecessary path segments
|
78 | async fn generic_type_param<T: Send>(x: Box<T>) -> T {
|
error: unnecessary qualification
--> tests/test.rs:78:58
|
78 | async fn generic_type_param<T: Send>(x: Box<T>) -> T {
| __________________________________________________________^
79 | | *x
80 | | }
| |_____^
|
help: remove the unnecessary path segments
|
78 | async fn generic_type_param<T: Send>(x: Box<T>) -> T {
|
error: unnecessary qualification
--> tests/test.rs:82:5
|
82 | async fn calls(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
82 | async fn calls(&self) {
|
error: unnecessary qualification
--> tests/test.rs:88:5
|
88 | async fn calls_mut(&mut self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
88 | async fn calls_mut(&mut self) {
|
error: unnecessary qualification
--> tests/test.rs:112:9
|
112 | async fn f(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
112 | async fn f(&self);
|
error: unnecessary qualification
--> tests/test.rs:117:9
|
117 | async fn f(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
117 | async fn f(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:127:9
|
127 | async fn f(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
127 | async fn f(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:132:9
|
132 | async fn f(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
132 | async fn f(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:171:9
|
171 | async fn f(&self, foos: (u8, u8, u8, u8));
| ^^^^^
|
help: remove the unnecessary path segments
|
171 | async fn f(&self, foos: (u8, u8, u8, u8));
|
error: unnecessary qualification
--> tests/test.rs:176:9
|
176 | async fn f(&self, (a, ref mut b, ref c, d): (u8, u8, u8, u8)) {
| ^^^^^
|
help: remove the unnecessary path segments
|
176 | async fn f(&self, (a, ref mut b, ref c, d): (u8, u8, u8, u8)) {
|
error: unnecessary qualification
--> tests/test.rs:190:9
|
190 | async fn a(self);
| ^^^^^
|
help: remove the unnecessary path segments
|
190 | async fn a(self);
|
error: unnecessary qualification
--> tests/test.rs:191:9
|
191 | async fn b(&mut self);
| ^^^^^
|
help: remove the unnecessary path segments
|
191 | async fn b(&mut self);
|
error: unnecessary qualification
--> tests/test.rs:192:9
|
192 | async fn c(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
192 | async fn c(&self);
|
error: unnecessary qualification
--> tests/test.rs:197:9
|
197 | async fn a(self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
197 | async fn a(self) {
|
error: unnecessary qualification
--> tests/test.rs:200:9
|
200 | async fn b(&mut self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
200 | async fn b(&mut self) {
|
error: unnecessary qualification
--> tests/test.rs:203:9
|
203 | async fn c(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
203 | async fn c(&self) {
|
error: unnecessary qualification
--> tests/test.rs:216:9
|
216 | async fn f() -> Box<dyn Iterator<Item = ()>> {
| ^^^^^
|
help: remove the unnecessary path segments
|
216 | async fn f() -> Box<dyn Iterator<Item = ()>> {
|
error: unnecessary qualification
--> tests/test.rs:216:54
|
216 | async fn f() -> Box<dyn Iterator<Item = ()>> {
| ______________________________________________________^
217 | | Box::new(std::iter::empty())
218 | | }
| |_________^
|
help: remove the unnecessary path segments
|
216 | async fn f() -> Box<dyn Iterator<Item = ()>> {
|
error: unnecessary qualification
--> tests/test.rs:230:9
|
230 | async fn f(self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
230 | async fn f(self) {
|
error: unnecessary qualification
--> tests/test.rs:245:9
|
245 | async fn f() {
| ^^^^^
|
help: remove the unnecessary path segments
|
245 | async fn f() {
|
error: unnecessary qualification
--> tests/test.rs:261:9
|
261 | async fn f<U>(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
261 | async fn f<U>(&self);
|
error: unnecessary qualification
--> tests/test.rs:266:9
|
266 | async fn f<U>(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
266 | async fn f<U>(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:277:9
|
277 | async fn flatten(self) -> <Self::Output as Future>::Output
| ^^^^^
|
help: remove the unnecessary path segments
|
277 | async fn flatten(self) -> <Self::Output as Future>::Output
|
error: unnecessary qualification
--> tests/test.rs:281:9
|
281 | / {
282 | | let nested_future = self.await;
283 | | nested_future.await
284 | | }
| |_________^
|
help: remove the unnecessary path segments
|
281 | {
|
error: unnecessary qualification
--> tests/test.rs:294:9
|
294 | async fn f(_x: Self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
294 | async fn f(_x: Self) {}
|
error: unnecessary qualification
--> tests/test.rs:305:9
|
305 | async fn example(self: Arc<Self>);
| ^^^^^
|
help: remove the unnecessary path segments
|
305 | async fn example(self: Arc<Self>);
|
error: unnecessary qualification
--> tests/test.rs:312:9
|
312 | async fn example(self: Arc<Self>) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
312 | async fn example(self: Arc<Self>) {}
|
error: unnecessary qualification
--> tests/test.rs:325:9
|
325 | async fn myfn(&self, _: PhantomData<dyn Trait + Send>) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
325 | async fn myfn(&self, _: PhantomData<dyn Trait + Send>) {}
|
error: unnecessary qualification
--> tests/test.rs:335:9
|
335 | async fn f(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
335 | async fn f(&self);
|
error: unnecessary qualification
--> tests/test.rs:344:9
|
344 | async fn f(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
344 | async fn f(&self) {
|
error: unnecessary qualification
--> tests/test.rs:356:9
|
356 | async fn f(self);
| ^^^^^
|
help: remove the unnecessary path segments
|
356 | async fn f(self);
|
error: unnecessary qualification
--> tests/test.rs:358:9
|
358 | async fn g(mut self)
| ^^^^^
|
help: remove the unnecessary path segments
|
358 | async fn g(mut self)
|
error: unnecessary qualification
--> tests/test.rs:371:9
|
371 | async fn f(mut self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
371 | async fn f(mut self) {
|
error: unnecessary qualification
--> tests/test.rs:434:9
|
434 | async fn f(x: Str<'a>) -> &'a str;
| ^^^^^
|
help: remove the unnecessary path segments
|
434 | async fn f(x: Str<'a>) -> &'a str;
|
error: unnecessary qualification
--> tests/test.rs:435:9
|
435 | async fn g(x: Str<'a>) -> &'a str {
| ^^^^^
|
help: remove the unnecessary path segments
|
435 | async fn g(x: Str<'a>) -> &'a str {
|
error: unnecessary qualification
--> tests/test.rs:435:43
|
435 | async fn g(x: Str<'a>) -> &'a str {
| ___________________________________________^
436 | | x.0
437 | | }
| |_________^
|
help: remove the unnecessary path segments
|
435 | async fn g(x: Str<'a>) -> &'a str {
|
error: unnecessary qualification
--> tests/test.rs:442:9
|
442 | async fn f(x: Str<'a>) -> &'a str {
| ^^^^^
|
help: remove the unnecessary path segments
|
442 | async fn f(x: Str<'a>) -> &'a str {
|
error: unnecessary qualification
--> tests/test.rs:442:43
|
442 | async fn f(x: Str<'a>) -> &'a str {
| ___________________________________________^
443 | | x.0
444 | | }
| |_________^
|
help: remove the unnecessary path segments
|
442 | async fn f(x: Str<'a>) -> &'a str {
|
error: unnecessary qualification
--> tests/test.rs:449:9
|
449 | async fn f();
| ^^^^^
|
help: remove the unnecessary path segments
|
449 | async fn f();
|
error: unnecessary qualification
--> tests/test.rs:454:9
|
454 | async fn f() {}
| ^^^^^
|
help: remove the unnecessary path segments
|
454 | async fn f() {}
|
error: unnecessary qualification
--> tests/test.rs:459:9
|
459 | async fn f(_: &'a &'b ()); // chain 'a and 'b
| ^^^^^
|
help: remove the unnecessary path segments
|
459 | async fn f(_: &'a &'b ()); // chain 'a and 'b
|
error: unnecessary qualification
--> tests/test.rs:460:9
|
460 | async fn g(_: &'b ()); // chain 'b only
| ^^^^^
|
help: remove the unnecessary path segments
|
460 | async fn g(_: &'b ()); // chain 'b only
|
error: unnecessary qualification
--> tests/test.rs:461:9
|
461 | async fn h(); // do not chain
| ^^^^^
|
help: remove the unnecessary path segments
|
461 | async fn h(); // do not chain
|
error: unnecessary qualification
--> tests/test.rs:475:9
|
475 | async fn hello(thing: Struct<'a>) -> String;
| ^^^^^
|
help: remove the unnecessary path segments
|
475 | async fn hello(thing: Struct<'a>) -> String;
|
error: unnecessary qualification
--> tests/test.rs:476:9
|
476 | async fn hello_twice(one: Struct<'a>, two: Struct<'a>) -> String {
| ^^^^^
|
help: remove the unnecessary path segments
|
476 | async fn hello_twice(one: Struct<'a>, two: Struct<'a>) -> String {
|
error: unnecessary qualification
--> tests/test.rs:476:74
|
476 | async fn hello_twice(one: Struct<'a>, two: Struct<'a>) -> String {
| __________________________________________________________________________^
477 | | let str1 = Self::hello(one).await;
478 | | let str2 = Self::hello(two).await;
479 | | str1 + &str2
480 | | }
| |_________^
|
help: remove the unnecessary path segments
|
476 | async fn hello_twice(one: Struct<'a>, two: Struct<'a>) -> String {
|
error: unnecessary qualification
--> tests/test.rs:490:9
|
490 | async fn from_parts() -> Self;
| ^^^^^
|
help: remove the unnecessary path segments
|
490 | async fn from_parts() -> Self;
|
error: unnecessary qualification
--> tests/test.rs:497:9
|
497 | async fn from_parts() -> TokenContext {
| ^^^^^
|
help: remove the unnecessary path segments
|
497 | async fn from_parts() -> TokenContext {
|
error: unnecessary qualification
--> tests/test.rs:497:47
|
497 | async fn from_parts() -> TokenContext {
| _______________________________________________^
498 | | TokenContext
499 | | }
| |_________^
|
help: remove the unnecessary path segments
|
497 | async fn from_parts() -> TokenContext {
|
error: unnecessary qualification
--> tests/test.rs:513:9
|
513 | async fn get_one() -> u8 {
| ^^^^^
|
help: remove the unnecessary path segments
|
513 | async fn get_one() -> u8 {
|
error: unnecessary qualification
--> tests/test.rs:513:34
|
513 | async fn get_one() -> u8 {
| __________________________________^
514 | | 1
515 | | }
| |_________^
|
help: remove the unnecessary path segments
|
513 | async fn get_one() -> u8 {
|
error: unnecessary qualification
--> tests/test.rs:538:9
|
538 | async fn foo(&mut self, v: usize);
| ^^^^^
|
help: remove the unnecessary path segments
|
538 | async fn foo(&mut self, v: usize);
|
error: unnecessary qualification
--> tests/test.rs:543:9
|
543 | async fn bar(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
543 | async fn bar(&self);
|
error: unnecessary qualification
--> tests/test.rs:552:9
|
552 | async fn foo(&mut self, v: usize) {
| ^^^^^
|
help: remove the unnecessary path segments
|
552 | async fn foo(&mut self, v: usize) {
|
error: unnecessary qualification
--> tests/test.rs:564:9
|
564 | async fn bar(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
564 | async fn bar(&self) {
|
error: unnecessary qualification
--> tests/test.rs:703:9
|
703 | async fn method();
| ^^^^^
|
help: remove the unnecessary path segments
|
703 | async fn method();
|
error: unnecessary qualification
--> tests/test.rs:708:9
|
708 | async fn method() {
| ^^^^^
|
help: remove the unnecessary path segments
|
708 | async fn method() {
|
error: unnecessary qualification
--> tests/test.rs:715:9
|
715 | async fn method() {
| ^^^^^
|
help: remove the unnecessary path segments
|
715 | async fn method() {
|
error: unnecessary qualification
--> tests/test.rs:722:9
|
722 | async fn method() {
| ^^^^^
|
help: remove the unnecessary path segments
|
722 | async fn method() {
|
error: unnecessary qualification
--> tests/test.rs:729:9
|
729 | async fn method() {
| ^^^^^
|
help: remove the unnecessary path segments
|
729 | async fn method() {
|
error: unnecessary qualification
--> tests/test.rs:742:9
|
742 | async fn const_generic<T: Send, const C: usize>(_: [T; C]) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
742 | async fn const_generic<T: Send, const C: usize>(_: [T; C]) {}
|
error: unnecessary qualification
--> tests/test.rs:749:9
|
749 | async fn const_generic<T: Send, const C: usize>(_: [T; C]) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
749 | async fn const_generic<T: Send, const C: usize>(_: [T; C]) {}
|
error: unnecessary qualification
--> tests/test.rs:763:9
|
763 | async fn method(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
763 | async fn method(&self) {
|
error: unnecessary qualification
--> tests/test.rs:782:9
|
782 | async fn associated(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
782 | async fn associated(&self) {
|
error: unnecessary qualification
--> tests/test.rs:794:9
|
794 | async fn handle(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
794 | async fn handle(&self);
|
error: unnecessary qualification
--> tests/test.rs:803:9
|
803 | async fn handle(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
803 | async fn handle(&self) {
|
error: unnecessary qualification
--> tests/test.rs:818:9
|
818 | async fn f(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
818 | async fn f(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:819:9
|
819 | async fn g(self: &Self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
819 | async fn g(self: &Self) {}
|
error: unnecessary qualification
--> tests/test.rs:832:9
|
832 | async fn camelCase();
| ^^^^^
|
help: remove the unnecessary path segments
|
832 | async fn camelCase();
|
error: unnecessary qualification
--> tests/test.rs:839:9
|
839 | async fn camelCase() {}
| ^^^^^
|
help: remove the unnecessary path segments
|
839 | async fn camelCase() {}
|
error: unnecessary qualification
--> tests/test.rs:849:9
|
849 | async fn f(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
849 | async fn f(&self);
|
error: unnecessary qualification
--> tests/test.rs:862:9
|
862 | async fn f(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
862 | async fn f(&self) {
|
error: unnecessary qualification
--> tests/test.rs:872:9
|
872 | async fn f(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
872 | async fn f(&self) {
|
error: unnecessary qualification
--> tests/test.rs:888:9
|
888 | async fn f(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
888 | async fn f(&self);
|
error: unnecessary qualification
--> tests/test.rs:893:9
|
893 | async fn f(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
893 | async fn f(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:898:9
|
898 | async fn f(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
898 | async fn f(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:903:9
|
903 | async fn f(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
903 | async fn f(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:935:9
|
935 | async fn associated2(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
935 | async fn associated2(&self) {
|
error: unnecessary qualification
--> tests/test.rs:958:9
|
958 | async fn associated2(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
958 | async fn associated2(&self) {
|
error: unnecessary qualification
--> tests/test.rs:983:9
|
983 | async fn associated2(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
983 | async fn associated2(&self) {
|
error: unnecessary qualification
--> tests/test.rs:1005:9
|
1005 | async fn func2() {
| ^^^^^
|
help: remove the unnecessary path segments
|
1005 | async fn func2() {
|
error: unnecessary qualification
--> tests/test.rs:1024:9
|
1024 | async fn id(&self) -> i32;
| ^^^^^
|
help: remove the unnecessary path segments
|
1024 | async fn id(&self) -> i32;
|
error: unnecessary qualification
--> tests/test.rs:1052:9
|
1052 | async fn spawn<F, Fut, T>(&self, work: F) -> T
| ^^^^^
|
help: remove the unnecessary path segments
|
1052 | async fn spawn<F, Fut, T>(&self, work: F) -> T
|
error: unnecessary qualification
--> tests/test.rs:1065:9
|
1065 | async fn spawn<F, Fut, T>(&self, work: F) -> T
| ^^^^^
|
help: remove the unnecessary path segments
|
1065 | async fn spawn<F, Fut, T>(&self, work: F) -> T
|
error: unnecessary qualification
--> tests/test.rs:1069:9
|
1069 | / {
1070 | | (**self).spawn(work).await
1071 | | }
| |_________^
|
help: remove the unnecessary path segments
|
1069 | {
|
error: unnecessary qualification
--> tests/test.rs:1082:9
|
1082 | async fn load(&self, key: &str);
| ^^^^^
|
help: remove the unnecessary path segments
|
1082 | async fn load(&self, key: &str);
|
error: unnecessary qualification
--> tests/test.rs:1091:9
|
1091 | async fn load(&self, _key: &str) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1091 | async fn load(&self, _key: &str) {}
|
error: unnecessary qualification
--> tests/test.rs:1103:9
|
1103 | async fn f(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
1103 | async fn f(&self);
|
error: unnecessary qualification
--> tests/test.rs:1108:9
|
1108 | async fn f(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1108 | async fn f(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:1118:9
|
1118 | async fn f(&self) -> &str
| ^^^^^
|
help: remove the unnecessary path segments
|
1118 | async fn f(&self) -> &str
|
error: unnecessary qualification
--> tests/test.rs:1121:9
|
1121 | / {
1122 | | "default"
1123 | | }
| |_________^
|
help: remove the unnecessary path segments
|
1121 | {
|
error: unnecessary qualification
--> tests/test.rs:1136:9
|
1136 | async fn a(_b: u8, c: u8) -> u8 {
| ^^^^^
|
help: remove the unnecessary path segments
|
1136 | async fn a(_b: u8, c: u8) -> u8 {
|
error: unnecessary qualification
--> tests/test.rs:1136:41
|
1136 | async fn a(_b: u8, c: u8) -> u8 {
| _________________________________________^
1137 | | c
1138 | | }
| |_________^
|
help: remove the unnecessary path segments
|
1136 | async fn a(_b: u8, c: u8) -> u8 {
|
error: unnecessary qualification
--> tests/test.rs:1145:9
|
1145 | async fn a(_b: u8, c: u8) -> u8 {
| ^^^^^
|
help: remove the unnecessary path segments
|
1145 | async fn a(_b: u8, c: u8) -> u8 {
|
error: unnecessary qualification
--> tests/test.rs:1145:41
|
1145 | async fn a(_b: u8, c: u8) -> u8 {
| _________________________________________^
1146 | | c
1147 | | }
| |_________^
|
help: remove the unnecessary path segments
|
1145 | async fn a(_b: u8, c: u8) -> u8 {
|
error: unnecessary qualification
--> tests/test.rs:1157:9
|
1157 | async fn run<const DUMMY: bool>(self)
| ^^^^^
|
help: remove the unnecessary path segments
|
1157 | async fn run<const DUMMY: bool>(self)
|
error: unnecessary qualification
--> tests/test.rs:1168:9
|
1168 | async fn run<const DUMMY: bool>(self)
| ^^^^^
|
help: remove the unnecessary path segments
|
1168 | async fn run<const DUMMY: bool>(self)
|
error: unnecessary qualification
--> tests/test.rs:1192:9
|
1192 | async fn async_trait(_: Flagger<'_>, flag: &AtomicBool);
| ^^^^^
|
help: remove the unnecessary path segments
|
1192 | async fn async_trait(_: Flagger<'_>, flag: &AtomicBool);
|
error: unnecessary qualification
--> tests/test.rs:1199:9
|
1199 | async fn async_trait(_: Flagger<'_>, flag: &AtomicBool) {
| ^^^^^
|
help: remove the unnecessary path segments
|
1199 | async fn async_trait(_: Flagger<'_>, flag: &AtomicBool) {
|
error: unnecessary qualification
--> tests/test.rs:1210:9
|
1210 | async fn async_trait(self, flag: &AtomicBool);
| ^^^^^
|
help: remove the unnecessary path segments
|
1210 | async fn async_trait(self, flag: &AtomicBool);
|
error: unnecessary qualification
--> tests/test.rs:1215:9
|
1215 | async fn async_trait(self, flag: &AtomicBool) {
| ^^^^^
|
help: remove the unnecessary path segments
|
1215 | async fn async_trait(self, flag: &AtomicBool) {
|
error: unnecessary qualification
--> tests/test.rs:1248:9
|
1248 | async fn connect(&self) -> Result<Self::Connection, Self::Error>;
| ^^^^^
|
help: remove the unnecessary path segments
|
1248 | async fn connect(&self) -> Result<Self::Connection, Self::Error>;
|
error: unnecessary qualification
--> tests/test.rs:1262:9
|
1262 | async fn x();
| ^^^^^
|
help: remove the unnecessary path segments
|
1262 | async fn x();
|
error: unnecessary qualification
--> tests/test.rs:1263:9
|
1263 | async fn y() -> ();
| ^^^^^
|
help: remove the unnecessary path segments
|
1263 | async fn y() -> ();
|
error: unnecessary qualification
--> tests/test.rs:1264:9
|
1264 | async fn z();
| ^^^^^
|
help: remove the unnecessary path segments
|
1264 | async fn z();
|
error: unnecessary qualification
--> tests/test.rs:1269:9
|
1269 | async fn x() {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1269 | async fn x() {}
|
error: unnecessary qualification
--> tests/test.rs:1270:9
|
1270 | async fn y() -> () {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1270 | async fn y() -> () {}
|
error: unnecessary qualification
--> tests/test.rs:1270:28
|
1270 | async fn y() -> () {}
| ^^
|
help: remove the unnecessary path segments
|
1270 | async fn y() -> () {}
|
error: unnecessary qualification
--> tests/test.rs:1271:9
|
1271 | async fn z() {
| ^^^^^
|
help: remove the unnecessary path segments
|
1271 | async fn z() {
|
error: unnecessary qualification
--> tests/test.rs:1291:9
|
1291 | async fn fail() -> &'static dyn Ret {
| ^^^^^
|
help: remove the unnecessary path segments
|
1291 | async fn fail() -> &'static dyn Ret {
|
error: unnecessary qualification
--> tests/test.rs:1291:45
|
1291 | async fn fail() -> &'static dyn Ret {
| _____________________________________________^
1292 | | return &Thing;
1293 | | }
| |_________^
|
help: remove the unnecessary path segments
|
1291 | async fn fail() -> &'static dyn Ret {
|
error: unnecessary qualification
--> tests/test.rs:1327:9
|
1327 | async fn f(&self);
| ^^^^^
|
help: remove the unnecessary path segments
|
1327 | async fn f(&self);
|
error: unnecessary qualification
--> tests/test.rs:1334:9
|
1334 | async fn f(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
1334 | async fn f(&self) {
|
error: unnecessary qualification
--> tests/test.rs:1349:9
|
1349 | async fn f(&self) {
| ^^^^^
|
help: remove the unnecessary path segments
|
1349 | async fn f(&self) {
|
error: unnecessary qualification
--> tests/test.rs:1350:13
|
1350 | self::f();
| ^^^^^^^
|
help: remove the unnecessary path segments
|
1350 - self::f();
1350 + f();
|
error: unnecessary qualification
--> tests/test.rs:1364:9
|
1364 | async fn f(self: Arc<Self>);
| ^^^^^
|
help: remove the unnecessary path segments
|
1364 | async fn f(self: Arc<Self>);
|
error: unnecessary qualification
--> tests/test.rs:1371:9
|
1371 | async fn f(self: Arc<Self>) {
| ^^^^^
|
help: remove the unnecessary path segments
|
1371 | async fn f(self: Arc<Self>) {
|
error: unnecessary qualification
--> tests/test.rs:1388:9
|
1388 | async fn f(&self) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1388 | async fn f(&self) {}
|
error: unnecessary qualification
--> tests/test.rs:1400:9
|
1400 | async fn foo(&self, _callback: impl FnMut(&str) + Send) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1400 | async fn foo(&self, _callback: impl FnMut(&str) + Send) {}
|
error: unnecessary qualification
--> tests/test.rs:1407:9
|
1407 | async fn foo(&self, _callback: impl FnMut(&str) + Send) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1407 | async fn foo(&self, _callback: impl FnMut(&str) + Send) {}
|
error: unnecessary qualification
--> tests/test.rs:1419:9
|
1419 | async fn foo(_n: i32) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1419 | async fn foo(_n: i32) {}
|
error: unnecessary qualification
--> tests/test.rs:1438:9
|
1438 | async fn f(counter: &Cell<usize>, arg: IncrementOnDrop<'_>);
| ^^^^^
|
help: remove the unnecessary path segments
|
1438 | async fn f(counter: &Cell<usize>, arg: IncrementOnDrop<'_>);
|
error: unnecessary qualification
--> tests/test.rs:1445:9
|
1445 | async fn f(counter: &Cell<usize>, _: IncrementOnDrop<'_>) {
| ^^^^^
|
help: remove the unnecessary path segments
|
1445 | async fn f(counter: &Cell<usize>, _: IncrementOnDrop<'_>) {
|
error: unnecessary qualification
--> tests/test.rs:1466:9
|
1466 | async fn f(arg: &impl Trait);
| ^^^^^
|
help: remove the unnecessary path segments
|
1466 | async fn f(arg: &impl Trait);
|
error: unnecessary qualification
--> tests/test.rs:1467:9
|
1467 | async fn g(arg: *const impl Trait);
| ^^^^^
|
help: remove the unnecessary path segments
|
1467 | async fn g(arg: *const impl Trait);
|
error: unnecessary qualification
--> tests/test.rs:1478:9
|
1478 | async fn f(self: Arc<Self>) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1478 | async fn f(self: Arc<Self>) {}
|
error: unnecessary qualification
--> tests/test.rs:1488:9
|
1488 | async fn cfg_param(&self, param: u8);
| ^^^^^
|
help: remove the unnecessary path segments
|
1488 | async fn cfg_param(&self, param: u8);
|
error: unnecessary qualification
--> tests/test.rs:1489:9
|
1489 | async fn cfg_param_wildcard(&self, _: u8);
| ^^^^^
|
help: remove the unnecessary path segments
|
1489 | async fn cfg_param_wildcard(&self, _: u8);
|
error: unnecessary qualification
--> tests/test.rs:1490:9
|
1490 | async fn cfg_param_tuple(&self, (left, right): (u8, u8));
| ^^^^^
|
help: remove the unnecessary path segments
|
1490 | async fn cfg_param_tuple(&self, (left, right): (u8, u8));
|
error: unnecessary qualification
--> tests/test.rs:1498:9
|
1498 | async fn cfg_param(&self, #[cfg(any())] param: u8, #[cfg(all())] _unused: u8) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1498 | async fn cfg_param(&self, #[cfg(any())] param: u8, #[cfg(all())] _unused: u8) {}
|
error: unnecessary qualification
--> tests/test.rs:1500:9
|
1500 | async fn cfg_param_wildcard(&self, #[cfg(any())] _: u8, #[cfg(all())] _: u8) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1500 | async fn cfg_param_wildcard(&self, #[cfg(any())] _: u8, #[cfg(all())] _: u8) {}
|
error: unnecessary qualification
--> tests/test.rs:1502:9
|
1502 | async fn cfg_param_tuple(
| ^^^^^
|
help: remove the unnecessary path segments
|
1502 | async fn cfg_param_tuple(
|
error: unnecessary qualification
--> tests/test.rs:1517:9
|
1517 | async fn take_ref(&self, thing: &T);
| ^^^^^
|
help: remove the unnecessary path segments
|
1517 | async fn take_ref(&self, thing: &T);
|
error: unnecessary qualification
--> tests/test.rs:1524:9
|
1524 | async fn take_ref(&self, _: &T) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1524 | async fn take_ref(&self, _: &T) {}
|
error: unnecessary qualification
--> tests/test.rs:1531:9
|
1531 | async fn take_ref(&self, (a, b): &(T, T)) {
| ^^^^^
|
help: remove the unnecessary path segments
|
1531 | async fn take_ref(&self, (a, b): &(T, T)) {
|
error: unnecessary qualification
--> tests/test.rs:1541:9
|
1541 | async fn take_ref(&self, (_a, _b, _c): &(T, T, T)) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1541 | async fn take_ref(&self, (_a, _b, _c): &(T, T, T)) {}
|
error: unnecessary qualification
--> tests/test.rs:1559:9
|
1559 | async fn f(arg: Tuple<Droppable, i32>);
| ^^^^^
|
help: remove the unnecessary path segments
|
1559 | async fn f(arg: Tuple<Droppable, i32>);
|
error: unnecessary qualification
--> tests/test.rs:1566:9
|
1566 | async fn f(Tuple(_, _int): Tuple<Droppable, i32>) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1566 | async fn f(Tuple(_, _int): Tuple<Droppable, i32>) {}
|
error: unnecessary qualification
--> tests/test.rs:1573:9
|
1573 | async fn f(Tuple { 1: _int, .. }: Tuple<Droppable, i32>) {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1573 | async fn f(Tuple { 1: _int, .. }: Tuple<Droppable, i32>) {}
|
error: unnecessary qualification
--> tests/test.rs:1599:9
|
1599 | async fn f() -> Ready<()> {
| ^^^^^
|
help: remove the unnecessary path segments
|
1599 | async fn f() -> Ready<()> {
|
error: unnecessary qualification
--> tests/test.rs:1599:35
|
1599 | async fn f() -> Ready<()> {
| ___________________________________^
1600 | | future::ready(())
1601 | | }
| |_________^
|
help: remove the unnecessary path segments
|
1599 | async fn f() -> Ready<()> {
|
error: unnecessary qualification
--> tests/test.rs:1613:9
|
1613 | async fn f();
| ^^^^^
|
help: remove the unnecessary path segments
|
1613 | async fn f();
|
error: unnecessary qualification
--> tests/test.rs:1620:9
|
1620 | async fn f() {}
| ^^^^^
|
help: remove the unnecessary path segments
|
1620 | async fn f() {}
|- Loading branch information
