1// edition:2015
2// run-rustfix
3// aux-build:wildcard_imports_helper.rs
4
5// the 2015 edition here is needed because edition 2018 changed the module system
6// (see https://doc.rust-lang.org/edition-guide/rust-2018/path-changes.html) which means the lint
7// no longer detects some of the cases starting with Rust 2018.
8// FIXME: We should likely add another edition 2021 test case for this lint
9
10#![warn(clippy::wildcard_imports)]
11#![allow(unused)]
12#![allow(clippy::unnecessary_wraps)]
13#![warn(unused_imports)]
14
15extern crate wildcard_imports_helper;
16
17use crate::fn_mod::foo;
18use crate::mod_mod::inner_mod;
19use crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod};
20#[macro_use]
21use crate::struct_mod::{A, inner_struct_mod};
22
23#[allow(unused_imports)]
24use wildcard_imports_helper::inner::inner_for_self_import;
25use wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar;
26use wildcard_imports_helper::{ExternA, extern_foo};
27
28use std::io::prelude::*;
29use wildcard_imports_helper::prelude::v1::*;
30
31struct ReadFoo;
32
33impl Read for ReadFoo {
34    fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
35        Ok(0)
36    }
37}
38
39mod fn_mod {
40    pub fn foo() {}
41}
42
43mod mod_mod {
44    pub mod inner_mod {
45        pub fn foo() {}
46    }
47}
48
49mod multi_fn_mod {
50    pub fn multi_foo() {}
51    pub fn multi_bar() {}
52    pub fn multi_baz() {}
53    pub mod multi_inner_mod {
54        pub fn foo() {}
55    }
56}
57
58mod struct_mod {
59    pub struct A;
60    pub struct B;
61    pub mod inner_struct_mod {
62        pub struct C;
63    }
64
65    #[macro_export]
66    macro_rules! double_struct_import_test {
67        () => {
68            let _ = A;
69        };
70    }
71}
72
73fn main() {
74    foo();
75    multi_foo();
76    multi_bar();
77    multi_inner_mod::foo();
78    inner_mod::foo();
79    extern_foo();
80    inner_extern_bar();
81
82    let _ = A;
83    let _ = inner_struct_mod::C;
84    let _ = ExternA;
85    let _ = PreludeModAnywhere;
86
87    double_struct_import_test!();
88    double_struct_import_test!();
89}
90
91mod in_fn_test {
92    pub use self::inner_exported::*;
93    #[allow(unused_imports)]
94    pub(crate) use self::inner_exported2::*;
95
96    fn test_intern() {
97        use crate::fn_mod::foo;
98
99        foo();
100    }
101
102    fn test_extern() {
103        use wildcard_imports_helper::inner::inner_for_self_import::{self, inner_extern_foo};
104        use wildcard_imports_helper::{ExternA, extern_foo};
105
106        inner_for_self_import::inner_extern_foo();
107        inner_extern_foo();
108
109        extern_foo();
110
111        let _ = ExternA;
112    }
113
114    fn test_inner_nested() {
115        use self::{inner::inner_foo, inner2::inner_bar};
116
117        inner_foo();
118        inner_bar();
119    }
120
121    fn test_extern_reexported() {
122        use wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported};
123
124        extern_exported();
125        let _ = ExternExportedStruct;
126        let _ = ExternExportedEnum::A;
127    }
128
129    mod inner_exported {
130        pub fn exported() {}
131        pub struct ExportedStruct;
132        pub enum ExportedEnum {
133            A,
134        }
135    }
136
137    mod inner_exported2 {
138        pub(crate) fn exported2() {}
139    }
140
141    mod inner {
142        pub fn inner_foo() {}
143    }
144
145    mod inner2 {
146        pub fn inner_bar() {}
147    }
148}
149
150fn test_reexported() {
151    use crate::in_fn_test::{ExportedEnum, ExportedStruct, exported};
152
153    exported();
154    let _ = ExportedStruct;
155    let _ = ExportedEnum::A;
156}
157
158#[rustfmt::skip]
159fn test_weird_formatting() {
160    use crate:: in_fn_test::exported;
161    use crate:: fn_mod::foo;
162
163    exported();
164    foo();
165}
166
167mod super_imports {
168    fn foofoo() {}
169
170    mod should_be_replaced {
171        use super::foofoo;
172
173        fn with_super() {
174            let _ = foofoo();
175        }
176    }
177
178    mod test_should_pass {
179        use super::*;
180
181        fn with_super() {
182            let _ = foofoo();
183        }
184    }
185
186    mod test_should_pass_inside_function {
187        fn with_super_inside_function() {
188            use super::*;
189            let _ = foofoo();
190        }
191    }
192
193    mod test_should_pass_further_inside {
194        fn insidefoo() {}
195        mod inner {
196            use super::*;
197            fn with_super() {
198                let _ = insidefoo();
199            }
200        }
201    }
202
203    mod should_be_replaced_futher_inside {
204        fn insidefoo() {}
205        mod inner {
206            use super::insidefoo;
207            fn with_super() {
208                let _ = insidefoo();
209            }
210        }
211    }
212
213    mod use_explicit_should_be_replaced {
214        use super_imports::foofoo;
215
216        fn with_explicit() {
217            let _ = foofoo();
218        }
219    }
220
221    mod use_double_super_should_be_replaced {
222        mod inner {
223            use super::super::foofoo;
224
225            fn with_double_super() {
226                let _ = foofoo();
227            }
228        }
229    }
230
231    mod use_super_explicit_should_be_replaced {
232        use super::super::super_imports::foofoo;
233
234        fn with_super_explicit() {
235            let _ = foofoo();
236        }
237    }
238
239    mod attestation_should_be_replaced {
240        use super::foofoo;
241
242        fn with_explicit() {
243            let _ = foofoo();
244        }
245    }
246}
247