rust/tests/ui/use_self.rs

495 lines
8.5 KiB
Rust
Raw Normal View History

2019-01-22 08:16:54 -06:00
// run-rustfix
2020-03-10 16:35:07 -05:00
// edition:2018
// aux-build:proc_macro_derive.rs
2019-01-22 08:16:54 -06:00
2018-07-28 10:34:52 -05:00
#![warn(clippy::use_self)]
#![allow(dead_code)]
#![allow(clippy::should_implement_trait, clippy::upper_case_acronyms, clippy::from_over_into)]
#[macro_use]
extern crate proc_macro_derive;
fn main() {}
mod use_self {
struct Foo {}
impl Foo {
fn new() -> Foo {
Foo {}
}
fn test() -> Foo {
Foo::new()
}
}
impl Default for Foo {
fn default() -> Foo {
Foo::new()
}
}
}
mod better {
struct Foo {}
impl Foo {
fn new() -> Self {
Self {}
}
fn test() -> Self {
Self::new()
}
}
impl Default for Foo {
fn default() -> Self {
Self::new()
}
}
}
2017-08-21 17:18:37 -05:00
mod lifetimes {
2018-12-09 16:26:16 -06:00
struct Foo<'a> {
foo_str: &'a str,
}
2017-08-21 17:18:37 -05:00
impl<'a> Foo<'a> {
2018-12-09 16:26:16 -06:00
// Cannot use `Self` as return type, because the function is actually `fn foo<'b>(s: &'b str) ->
// Foo<'b>`
2017-08-21 17:18:37 -05:00
fn foo(s: &str) -> Foo {
Foo { foo_str: s }
}
// cannot replace with `Self`, because that's `Foo<'a>`
fn bar() -> Foo<'static> {
2018-12-09 16:26:16 -06:00
Foo { foo_str: "foo" }
2017-08-21 17:18:37 -05:00
}
// FIXME: the lint does not handle lifetimed struct
2018-12-27 02:54:19 -06:00
// `Self` should be applicable here
2017-08-21 17:18:37 -05:00
fn clone(&self) -> Foo<'a> {
2018-12-09 16:26:16 -06:00
Foo { foo_str: self.foo_str }
2017-08-21 17:18:37 -05:00
}
}
}
2018-07-14 05:18:50 -05:00
mod issue2894 {
trait IntoBytes {
fn to_bytes(self) -> Vec<u8>;
2018-07-14 05:18:50 -05:00
}
// This should not be linted
impl IntoBytes for u8 {
fn to_bytes(self) -> Vec<u8> {
vec![self]
2018-07-14 05:18:50 -05:00
}
}
}
2018-10-24 22:28:54 -05:00
mod existential {
struct Foo;
impl Foo {
fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
2018-10-24 22:28:54 -05:00
foos.iter()
}
2018-12-09 16:26:16 -06:00
fn good(foos: &[Self]) -> impl Iterator<Item = &Self> {
2018-10-24 22:28:54 -05:00
foos.iter()
}
}
}
2018-12-27 10:27:42 -06:00
mod tuple_structs {
pub struct TS(i32);
impl TS {
pub fn ts() -> Self {
TS(0)
}
}
}
mod macros {
macro_rules! use_self_expand {
() => {
fn new() -> Foo {
Foo {}
}
};
}
struct Foo {}
impl Foo {
use_self_expand!(); // Should not lint in local macros
}
#[derive(StructAUseSelf)] // Should not lint in derives
struct A;
}
2019-01-06 08:05:04 -06:00
mod nesting {
struct Foo {}
impl Foo {
fn foo() {
#[allow(unused_imports)]
2019-01-06 08:05:04 -06:00
use self::Foo; // Can't use Self here
struct Bar {
foo: Foo, // Foo != Self
}
2019-01-07 07:11:53 -06:00
impl Bar {
fn bar() -> Bar {
2019-01-07 07:38:01 -06:00
Bar { foo: Foo {} }
2019-01-07 07:11:53 -06:00
}
}
// Can't use Self here
fn baz() -> Foo {
Foo {}
}
}
// Should lint here
fn baz() -> Foo {
Foo {}
2019-01-06 08:05:04 -06:00
}
}
enum Enum {
A,
B(u64),
2019-08-01 00:09:57 -05:00
C { field: bool },
2019-01-06 08:05:04 -06:00
}
impl Enum {
fn method() {
2019-01-22 08:16:54 -06:00
#[allow(unused_imports)]
2019-01-07 07:11:53 -06:00
use self::Enum::*; // Issue 3425
2019-01-06 08:05:04 -06:00
static STATIC: Enum = Enum::A; // Can't use Self as type
}
fn method2() {
let _ = Enum::B(42);
let _ = Enum::C { field: true };
let _ = Enum::A;
}
2019-01-06 08:05:04 -06:00
}
}
mod issue3410 {
struct A;
struct B;
trait Trait<T> {
fn a(v: T) -> Self;
}
impl Trait<Vec<A>> for Vec<B> {
fn a(_: Vec<A>) -> Self {
unimplemented!()
}
}
impl<T> Trait<Vec<A>> for Vec<T>
where
T: Trait<B>,
{
fn a(v: Vec<A>) -> Self {
<Vec<B>>::a(v).into_iter().map(Trait::a).collect()
}
}
}
2019-01-22 08:16:54 -06:00
#[allow(clippy::no_effect, path_statements)]
mod rustfix {
mod nested {
pub struct A {}
}
impl nested::A {
const A: bool = true;
fn fun_1() {}
fn fun_2() {
nested::A::fun_1();
nested::A::A;
nested::A {};
}
}
}
mod issue3567 {
struct TestStruct {}
impl TestStruct {
fn from_something() -> Self {
Self {}
}
}
trait Test {
fn test() -> TestStruct;
}
impl Test for TestStruct {
fn test() -> TestStruct {
TestStruct::from_something()
}
}
}
2019-11-06 21:59:13 -06:00
mod paths_created_by_lowering {
use std::ops::Range;
struct S {}
impl S {
const A: usize = 0;
const B: usize = 1;
2019-11-06 21:59:13 -06:00
async fn g() -> S {
S {}
}
fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
&p[S::A..S::B]
}
}
2019-11-06 21:59:13 -06:00
trait T {
fn f<'a>(&self, p: &'a [u8]) -> &'a [u8];
}
impl T for Range<u8> {
fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
&p[0..1]
}
}
}
// reused from #1997
mod generics {
struct Foo<T> {
value: T,
}
impl<T> Foo<T> {
// `Self` is applicable here
fn foo(value: T) -> Foo<T> {
Foo { value }
}
// `Cannot` use `Self` as a return type as the generic types are different
fn bar(value: i32) -> Foo<i32> {
Foo { value }
}
}
}
mod issue4140 {
pub struct Error<From, To> {
_from: From,
_too: To,
}
pub trait From<T> {
type From;
type To;
fn from(value: T) -> Self;
}
pub trait TryFrom<T>
where
Self: Sized,
{
type From;
type To;
fn try_from(value: T) -> Result<Self, Error<Self::From, Self::To>>;
}
2021-03-15 15:52:57 -05:00
// FIXME: Suggested fix results in infinite recursion.
// impl<F, T> TryFrom<F> for T
// where
// T: From<F>,
// {
// type From = Self::From;
// type To = Self::To;
// fn try_from(value: F) -> Result<Self, Error<Self::From, Self::To>> {
// Ok(From::from(value))
// }
// }
impl From<bool> for i64 {
type From = bool;
type To = Self;
fn from(value: bool) -> Self {
if value { 100 } else { 0 }
}
}
}
mod issue2843 {
trait Foo {
type Bar;
}
impl Foo for usize {
type Bar = u8;
}
impl<T: Foo> Foo for Option<T> {
type Bar = Option<T::Bar>;
}
}
mod issue3859 {
pub struct Foo;
pub struct Bar([usize; 3]);
impl Foo {
pub const BAR: usize = 3;
pub fn foo() {
const _X: usize = Foo::BAR;
// const _Y: usize = Self::BAR;
}
}
}
mod issue4305 {
trait Foo: 'static {}
struct Bar;
impl Foo for Bar {}
impl<T: Foo> From<T> for Box<dyn Foo> {
fn from(t: T) -> Self {
Box::new(t)
}
}
}
mod lint_at_item_level {
struct Foo {}
#[allow(clippy::use_self)]
impl Foo {
fn new() -> Foo {
Foo {}
}
}
#[allow(clippy::use_self)]
impl Default for Foo {
fn default() -> Foo {
Foo::new()
}
}
}
mod lint_at_impl_item_level {
struct Foo {}
impl Foo {
#[allow(clippy::use_self)]
fn new() -> Foo {
Foo {}
}
}
impl Default for Foo {
#[allow(clippy::use_self)]
fn default() -> Foo {
Foo::new()
}
}
}
mod issue4734 {
#[repr(C, packed)]
pub struct X {
pub x: u32,
}
impl From<X> for u32 {
fn from(c: X) -> Self {
unsafe { core::mem::transmute(c) }
}
}
}
mod nested_paths {
use std::convert::Into;
mod submod {
pub struct B {}
pub struct C {}
impl Into<C> for B {
fn into(self) -> C {
C {}
}
}
}
struct A<T> {
t: T,
}
impl<T> A<T> {
fn new<V: Into<T>>(v: V) -> Self {
Self { t: Into::into(v) }
}
}
impl A<submod::C> {
fn test() -> Self {
A::new::<submod::B>(submod::B {})
}
}
}
mod issue6818 {
#[derive(serde::Deserialize)]
struct A {
a: i32,
}
}
mod issue7206 {
struct MyStruct<const C: char>;
impl From<MyStruct<'a'>> for MyStruct<'b'> {
fn from(_s: MyStruct<'a'>) -> Self {
Self
}
}
// keep linting non-`Const` generic args
struct S<'a> {
inner: &'a str,
}
struct S2<T> {
inner: T,
}
impl<T> S2<T> {
fn new() -> Self {
unimplemented!();
}
}
impl<'a> S2<S<'a>> {
fn new_again() -> Self {
S2::new()
}
}
}