mirror of
https://github.com/rust-lang/rust-clippy
synced 2024-12-04 18:40:18 +00:00
271 lines
4 KiB
Rust
271 lines
4 KiB
Rust
//@run-rustfix
|
|
|
|
#![allow(dead_code)]
|
|
|
|
use std::collections::HashMap;
|
|
|
|
#[derive(Default)]
|
|
struct FooDefault<'a> {
|
|
a: bool,
|
|
b: i32,
|
|
c: u64,
|
|
d: Vec<i32>,
|
|
e: FooND1,
|
|
f: FooND2,
|
|
g: HashMap<i32, i32>,
|
|
h: (i32, Vec<i32>),
|
|
i: [Vec<i32>; 3],
|
|
j: [i32; 5],
|
|
k: Option<i32>,
|
|
l: &'a [i32],
|
|
}
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
struct TupleDefault(bool, i32, u64);
|
|
|
|
|
|
|
|
struct FooND1 {
|
|
a: bool,
|
|
}
|
|
|
|
impl std::default::Default for FooND1 {
|
|
fn default() -> Self {
|
|
Self { a: true }
|
|
}
|
|
}
|
|
|
|
struct FooND2 {
|
|
a: i32,
|
|
}
|
|
|
|
impl std::default::Default for FooND2 {
|
|
fn default() -> Self {
|
|
Self { a: 5 }
|
|
}
|
|
}
|
|
|
|
struct FooNDNew {
|
|
a: bool,
|
|
}
|
|
|
|
impl FooNDNew {
|
|
fn new() -> Self {
|
|
Self { a: true }
|
|
}
|
|
}
|
|
|
|
impl Default for FooNDNew {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
struct FooNDVec(Vec<i32>);
|
|
|
|
impl Default for FooNDVec {
|
|
fn default() -> Self {
|
|
Self(vec![5, 12])
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct StrDefault<'a>(&'a str);
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
struct AlreadyDerived(i32, bool);
|
|
|
|
macro_rules! mac {
|
|
() => {
|
|
0
|
|
};
|
|
($e:expr) => {
|
|
struct X(u32);
|
|
impl Default for X {
|
|
fn default() -> Self {
|
|
Self($e)
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
mac!(0);
|
|
|
|
#[derive(Default)]
|
|
struct Y(u32);
|
|
|
|
|
|
struct RustIssue26925<T> {
|
|
a: Option<T>,
|
|
}
|
|
|
|
// We should watch out for cases where a manual impl is needed because a
|
|
// derive adds different type bounds (https://github.com/rust-lang/rust/issues/26925).
|
|
// For example, a struct with Option<T> does not require T: Default, but a derive adds
|
|
// that type bound anyways. So until #26925 get fixed we should disable lint
|
|
// for the following case
|
|
impl<T> Default for RustIssue26925<T> {
|
|
fn default() -> Self {
|
|
Self { a: None }
|
|
}
|
|
}
|
|
|
|
struct SpecializedImpl<A, B> {
|
|
a: A,
|
|
b: B,
|
|
}
|
|
|
|
impl<T: Default> Default for SpecializedImpl<T, T> {
|
|
fn default() -> Self {
|
|
Self {
|
|
a: T::default(),
|
|
b: T::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct WithoutSelfCurly {
|
|
a: bool,
|
|
}
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
struct WithoutSelfParan(bool);
|
|
|
|
|
|
|
|
// https://github.com/rust-lang/rust-clippy/issues/7655
|
|
|
|
pub struct SpecializedImpl2<T> {
|
|
v: Vec<T>,
|
|
}
|
|
|
|
impl Default for SpecializedImpl2<String> {
|
|
fn default() -> Self {
|
|
Self { v: Vec::new() }
|
|
}
|
|
}
|
|
|
|
// https://github.com/rust-lang/rust-clippy/issues/7654
|
|
|
|
pub struct Color {
|
|
pub r: u8,
|
|
pub g: u8,
|
|
pub b: u8,
|
|
}
|
|
|
|
/// `#000000`
|
|
impl Default for Color {
|
|
fn default() -> Self {
|
|
Color { r: 0, g: 0, b: 0 }
|
|
}
|
|
}
|
|
|
|
pub struct Color2 {
|
|
pub r: u8,
|
|
pub g: u8,
|
|
pub b: u8,
|
|
}
|
|
|
|
impl Default for Color2 {
|
|
/// `#000000`
|
|
fn default() -> Self {
|
|
Self { r: 0, g: 0, b: 0 }
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct RepeatDefault1 {
|
|
a: [i8; 32],
|
|
}
|
|
|
|
|
|
|
|
pub struct RepeatDefault2 {
|
|
a: [i8; 33],
|
|
}
|
|
|
|
impl Default for RepeatDefault2 {
|
|
fn default() -> Self {
|
|
RepeatDefault2 { a: [0; 33] }
|
|
}
|
|
}
|
|
|
|
// https://github.com/rust-lang/rust-clippy/issues/7753
|
|
|
|
pub enum IntOrString {
|
|
Int(i32),
|
|
String(String),
|
|
}
|
|
|
|
impl Default for IntOrString {
|
|
fn default() -> Self {
|
|
IntOrString::Int(0)
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub enum SimpleEnum {
|
|
Foo,
|
|
#[default]
|
|
Bar,
|
|
}
|
|
|
|
|
|
|
|
pub enum NonExhaustiveEnum {
|
|
Foo,
|
|
#[non_exhaustive]
|
|
Bar,
|
|
}
|
|
|
|
impl Default for NonExhaustiveEnum {
|
|
fn default() -> Self {
|
|
NonExhaustiveEnum::Bar
|
|
}
|
|
}
|
|
|
|
// https://github.com/rust-lang/rust-clippy/issues/10396
|
|
|
|
#[derive(Default)]
|
|
struct DefaultType;
|
|
|
|
struct GenericType<T = DefaultType> {
|
|
t: T,
|
|
}
|
|
|
|
impl Default for GenericType {
|
|
fn default() -> Self {
|
|
Self { t: Default::default() }
|
|
}
|
|
}
|
|
|
|
struct InnerGenericType<T> {
|
|
t: T,
|
|
}
|
|
|
|
impl Default for InnerGenericType<DefaultType> {
|
|
fn default() -> Self {
|
|
Self { t: Default::default() }
|
|
}
|
|
}
|
|
|
|
struct OtherGenericType<T = DefaultType> {
|
|
inner: InnerGenericType<T>,
|
|
}
|
|
|
|
impl Default for OtherGenericType {
|
|
fn default() -> Self {
|
|
Self {
|
|
inner: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn main() {}
|