Ignore unused_qualifications rustc lint in generated code #260
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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() {}
|
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Fixes #259. The new lints in nightly-2024-03-05 are resulting from rust-lang/rust#121528.