mirror of
https://github.com/rust-lang/rust.git
synced 2024-12-13 00:56:14 +00:00
270 lines
5.3 KiB
Rust
270 lines
5.3 KiB
Rust
//@revisions: edition2018 edition2021
|
|
//@[edition2018] edition:2018
|
|
//@[edition2021] edition:2021
|
|
|
|
//@aux-build:wildcard_imports_helper.rs
|
|
|
|
#![warn(clippy::wildcard_imports)]
|
|
#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
|
|
#![warn(unused_imports)]
|
|
|
|
extern crate wildcard_imports_helper;
|
|
|
|
use crate::fn_mod::foo;
|
|
use crate::mod_mod::inner_mod;
|
|
use crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod};
|
|
use crate::struct_mod::{A, inner_struct_mod};
|
|
|
|
#[allow(unused_imports)]
|
|
use wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar;
|
|
use wildcard_imports_helper::prelude::v1::*;
|
|
use wildcard_imports_helper::{ExternA, extern_foo};
|
|
|
|
use std::io::prelude::*;
|
|
|
|
struct ReadFoo;
|
|
|
|
impl Read for ReadFoo {
|
|
fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
|
|
Ok(0)
|
|
}
|
|
}
|
|
|
|
mod fn_mod {
|
|
pub fn foo() {}
|
|
}
|
|
|
|
mod mod_mod {
|
|
pub mod inner_mod {
|
|
pub fn foo() {}
|
|
}
|
|
}
|
|
|
|
mod multi_fn_mod {
|
|
pub fn multi_foo() {}
|
|
pub fn multi_bar() {}
|
|
pub fn multi_baz() {}
|
|
pub mod multi_inner_mod {
|
|
pub fn foo() {}
|
|
}
|
|
}
|
|
|
|
mod struct_mod {
|
|
pub struct A;
|
|
pub struct B;
|
|
pub mod inner_struct_mod {
|
|
pub struct C;
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! double_struct_import_test {
|
|
() => {
|
|
let _ = A;
|
|
};
|
|
}
|
|
}
|
|
|
|
// issue 9942
|
|
mod underscore_mod {
|
|
// allow use of `deref` so that `clippy --fix` includes `Deref`.
|
|
#![allow(noop_method_call)]
|
|
|
|
mod exports_underscore {
|
|
pub use std::ops::Deref as _;
|
|
pub fn dummy() {}
|
|
}
|
|
|
|
mod exports_underscore_ish {
|
|
pub use std::ops::Deref as _Deref;
|
|
pub fn dummy() {}
|
|
}
|
|
|
|
fn does_not_lint() {
|
|
use exports_underscore::*;
|
|
let _ = (&0).deref();
|
|
dummy();
|
|
}
|
|
|
|
fn does_lint() {
|
|
use exports_underscore_ish::{_Deref, dummy};
|
|
let _ = (&0).deref();
|
|
dummy();
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
foo();
|
|
multi_foo();
|
|
multi_bar();
|
|
multi_inner_mod::foo();
|
|
inner_mod::foo();
|
|
extern_foo();
|
|
inner_extern_bar();
|
|
|
|
let _ = A;
|
|
let _ = inner_struct_mod::C;
|
|
let _ = ExternA;
|
|
let _ = PreludeModAnywhere;
|
|
|
|
double_struct_import_test!();
|
|
double_struct_import_test!();
|
|
}
|
|
|
|
mod in_fn_test {
|
|
pub use self::inner_exported::*;
|
|
#[allow(unused_imports)]
|
|
pub(crate) use self::inner_exported2::*;
|
|
|
|
fn test_intern() {
|
|
use crate::fn_mod::foo;
|
|
|
|
foo();
|
|
}
|
|
|
|
fn test_extern() {
|
|
use wildcard_imports_helper::inner::inner_for_self_import::{self, inner_extern_foo};
|
|
use wildcard_imports_helper::{ExternA, extern_foo};
|
|
|
|
inner_for_self_import::inner_extern_foo();
|
|
inner_extern_foo();
|
|
|
|
extern_foo();
|
|
|
|
let _ = ExternA;
|
|
}
|
|
|
|
fn test_inner_nested() {
|
|
#[rustfmt::skip]
|
|
use self::{inner::inner_foo, inner2::inner_bar};
|
|
|
|
inner_foo();
|
|
inner_bar();
|
|
}
|
|
|
|
fn test_extern_reexported() {
|
|
use wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported};
|
|
|
|
extern_exported();
|
|
let _ = ExternExportedStruct;
|
|
let _ = ExternExportedEnum::A;
|
|
}
|
|
|
|
mod inner_exported {
|
|
pub fn exported() {}
|
|
pub struct ExportedStruct;
|
|
pub enum ExportedEnum {
|
|
A,
|
|
}
|
|
}
|
|
|
|
mod inner_exported2 {
|
|
pub(crate) fn exported2() {}
|
|
}
|
|
|
|
mod inner {
|
|
pub fn inner_foo() {}
|
|
}
|
|
|
|
mod inner2 {
|
|
pub fn inner_bar() {}
|
|
}
|
|
}
|
|
|
|
fn test_reexported() {
|
|
use crate::in_fn_test::{ExportedEnum, ExportedStruct, exported};
|
|
|
|
exported();
|
|
let _ = ExportedStruct;
|
|
let _ = ExportedEnum::A;
|
|
}
|
|
|
|
#[rustfmt::skip]
|
|
fn test_weird_formatting() {
|
|
use crate:: in_fn_test::exported;
|
|
use crate:: fn_mod::foo;
|
|
|
|
exported();
|
|
foo();
|
|
}
|
|
|
|
mod super_imports {
|
|
fn foofoo() {}
|
|
|
|
mod should_be_replaced {
|
|
use super::foofoo;
|
|
|
|
fn with_super() {
|
|
let _ = foofoo();
|
|
}
|
|
}
|
|
|
|
mod test_should_pass {
|
|
use super::*;
|
|
|
|
fn with_super() {
|
|
let _ = foofoo();
|
|
}
|
|
}
|
|
|
|
mod test_should_pass_inside_function {
|
|
fn with_super_inside_function() {
|
|
use super::*;
|
|
let _ = foofoo();
|
|
}
|
|
}
|
|
|
|
mod test_should_pass_further_inside {
|
|
fn insidefoo() {}
|
|
mod inner {
|
|
use super::*;
|
|
fn with_super() {
|
|
let _ = insidefoo();
|
|
}
|
|
}
|
|
}
|
|
|
|
mod should_be_replaced_further_inside {
|
|
fn insidefoo() {}
|
|
mod inner {
|
|
use super::insidefoo;
|
|
fn with_super() {
|
|
let _ = insidefoo();
|
|
}
|
|
}
|
|
}
|
|
|
|
mod use_explicit_should_be_replaced {
|
|
use crate::super_imports::foofoo;
|
|
|
|
fn with_explicit() {
|
|
let _ = foofoo();
|
|
}
|
|
}
|
|
|
|
mod use_double_super_should_be_replaced {
|
|
mod inner {
|
|
use super::super::foofoo;
|
|
|
|
fn with_double_super() {
|
|
let _ = foofoo();
|
|
}
|
|
}
|
|
}
|
|
|
|
mod use_super_explicit_should_be_replaced {
|
|
use super::super::super_imports::foofoo;
|
|
|
|
fn with_super_explicit() {
|
|
let _ = foofoo();
|
|
}
|
|
}
|
|
|
|
mod attestation_should_be_replaced {
|
|
use super::foofoo;
|
|
|
|
fn with_explicit() {
|
|
let _ = foofoo();
|
|
}
|
|
}
|
|
}
|