#![warn(len_without_is_empty, len_zero)]
#![allow(dead_code, unused)]
pub struct PubOne;
impl PubOne {
pub fn len(self: &Self) -> isize {
1
}
}
impl PubOne {
pub fn irrelevant(self: &Self) -> bool {
false
}
}
pub struct PubAllowed;
#[allow(len_without_is_empty)]
impl PubAllowed {
pub fn len(self: &Self) -> isize {
1
}
}
impl PubAllowed {
pub fn irrelevant(self: &Self) -> bool {
false
}
}
struct NotPubOne;
impl NotPubOne {
pub fn len(self: &Self) -> isize {
1
}
}
struct One;
impl One {
fn len(self: &Self) -> isize {
1
}
}
pub trait PubTraitsToo {
fn len(self: &Self) -> isize;
}
impl PubTraitsToo for One {
fn len(self: &Self) -> isize {
0
}
}
trait TraitsToo {
fn len(self: &Self) -> isize; }
impl TraitsToo for One {
fn len(self: &Self) -> isize {
0
}
}
struct HasPrivateIsEmpty;
impl HasPrivateIsEmpty {
pub fn len(self: &Self) -> isize {
1
}
fn is_empty(self: &Self) -> bool {
false
}
}
pub struct HasIsEmpty;
impl HasIsEmpty {
pub fn len(self: &Self) -> isize {
1
}
fn is_empty(self: &Self) -> bool {
false
}
}
struct Wither;
pub trait WithIsEmpty {
fn len(self: &Self) -> isize;
fn is_empty(self: &Self) -> bool;
}
impl WithIsEmpty for Wither {
fn len(self: &Self) -> isize {
1
}
fn is_empty(self: &Self) -> bool {
false
}
}
pub struct HasWrongIsEmpty;
impl HasWrongIsEmpty {
pub fn len(self: &Self) -> isize {
1
}
pub fn is_empty(self: &Self, x: u32) -> bool {
false
}
}
pub trait Empty {
fn is_empty(&self) -> bool;
}
pub trait InheritingEmpty: Empty {
fn len(&self) -> isize;
}
fn main() {
let x = [1, 2];
if x.len() == 0 {
println!("This should not happen!");
}
if "".len() == 0 {}
let y = One;
if y.len() == 0 {
println!("This should not happen either!");
}
let z: &TraitsToo = &y;
if z.len() > 0 {
println!("Nor should this!");
}
let has_is_empty = HasIsEmpty;
if has_is_empty.len() == 0 {
println!("Or this!");
}
if has_is_empty.len() != 0 {
println!("Or this!");
}
if has_is_empty.len() > 0 {
println!("Or this!");
}
if has_is_empty.len() < 1 {
println!("Or this!");
}
if has_is_empty.len() >= 1 {
println!("Or this!");
}
if has_is_empty.len() > 1 {
println!("This can happen.");
}
if has_is_empty.len() <= 1 {
println!("This can happen.");
}
if 0 == has_is_empty.len() {
println!("Or this!");
}
if 0 != has_is_empty.len() {
println!("Or this!");
}
if 0 < has_is_empty.len() {
println!("Or this!");
}
if 1 <= has_is_empty.len() {
println!("Or this!");
}
if 1 > has_is_empty.len() {
println!("Or this!");
}
if 1 < has_is_empty.len() {
println!("This can happen.");
}
if 1 >= has_is_empty.len() {
println!("This can happen.");
}
assert!(!has_is_empty.is_empty());
let with_is_empty: &WithIsEmpty = &Wither;
if with_is_empty.len() == 0 {
println!("Or this!");
}
assert!(!with_is_empty.is_empty());
let has_wrong_is_empty = HasWrongIsEmpty;
if has_wrong_is_empty.len() == 0 {
println!("Or this!");
}
}
fn test_slice(b: &[u8]) {
if b.len() != 0 {}
}
pub trait Foo: Sized {}
pub trait DependsOnFoo: Foo {
fn len(&mut self) -> usize;
}