tests/ui/wildcard_imports.fixed

   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
  15 extern crate wildcard_imports_helper;
  16
  17 use crate::fn_mod::foo;
  18 use crate::mod_mod::inner_mod;
  19 use crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod};
  20 #[macro_use]
  21 use crate::struct_mod::{A, inner_struct_mod};
  22
  23 #[allow(unused_imports)]
  24 use wildcard_imports_helper::inner::inner_for_self_import;
  25 use wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar;
  26 use wildcard_imports_helper::{ExternA, extern_foo};
  27
  28 use std::io::prelude::*;
  29 use wildcard_imports_helper::prelude::v1::*;
  30
  31 struct ReadFoo;
  32
  33 impl Read for ReadFoo {
  34     fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
  35         Ok(0)
  36     }
  37 }
  38
  39 mod fn_mod {
  40     pub fn foo() {}
  41 }
  42
  43 mod mod_mod {
  44     pub mod inner_mod {
  45         pub fn foo() {}
  46     }
  47 }
  48
  49 mod 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
  58 mod 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
  73 fn 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
  91 mod 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
 150 fn 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]
 159 fn test_weird_formatting() {
 160     use crate:: in_fn_test::exported;
 161     use crate:: fn_mod::foo;
 162
 163     exported();
 164     foo();
 165 }
 166
 167 mod 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 }