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