Eq for Bytes returns true for unequal Bytes

[segfault-magnet]

Minimal example here: https://github.com/segfault-magnet/sway_bytes_eq_bug

script;

use std::string::String;
use std::assert::assert_eq;

fn main() {
    let string_a = String::from_ascii_str("Hello World");
    assert_eq(string_a.as_bytes().len(), 11);

    let string_b = String::from_ascii_str("NoNoNo");
    assert_eq(string_b.as_bytes().len(), 6);

    // Should not pass but it does
    assert_eq(string_a.as_bytes(), string_b.as_bytes());
}

forc build && cargo test

Tested on forc 0.42.1 and fuel-core 0.19

[Braqzen]

Could you add

assert(string_a.as_bytes() == string_b.as_bytes());

above the last line to see if that fails?

[bitzoic]

Could you add
assert(string_a.as_bytes() == string_b.as_bytes());
above the last line to see if that fails?

This fails. Seems like there might be a problem with the assert_eq function

[Braqzen]

Could you add
assert(string_a.as_bytes() == string_b.as_bytes());
above the last line to see if that fails?

This fails. Seems like there might be a problem with the assert_eq function

If that also fails then it's the Eq, no? Or do you mean that it passes and hence it's the assert_eq?

[IGI-111]

If __eq returns the right result then it's definitely a problem with std and the trait implementation for Bytes specifically.

[Braqzen]

If __eq returns the right result then it's definitely a problem with std and the trait implementation for Bytes specifically.

We check the length first which seems to work everywhere else

sway/sway-lib-std/src/bytes.sw

Lines 605 to 616 in cab7e33

	impl core::ops::Eq for Bytes {
	fn eq(self, other: Self) -> bool {
	if self.len != other.len {
	return false;
	}
	asm(result, r2: self.buf.ptr, r3: other.buf.ptr, r4: self.len) {
	meq result r2 r3 r4;
	result: bool
	}
	}
	}

[IGI-111]

Maybe the length is set wrong? Like zero or something?

[segfault-magnet]

    let string_a = String::from_ascii_str("Hello World");
    assert_eq(string_a.as_bytes().len(), 11);

    let string_b = String::from_ascii_str("NoNoNo");
    assert_eq(string_b.as_bytes().len(), 6);

It would seem that the len is OK. Tried changing 6 to 7 and it failed. So guess Eq works for u64 :D

[bitzoic]

I think it's related to the where clause with the Eq trait and not something in the std lib. I've created this test function and am seeing the following behavior when passing Bytes.

pub fn takes_generics_with_where_clause<T>(gen_1: T, gen_2: T) -> bool where T: Eq {
    // This evaluates the opposite
    return gen_1 != gen_2;
    // This evaluates the opposite
    return gen_1 == gen_2;
    // This evaluates the opposite
    if (gen_1 != gen_2) {
        return false;
    }
    // This has an internal compiler error
    if (gen_1 == gen_2) {
        return true;
    }
}

The assert() function takes a bool and the evaluation is done before entering the function, hence why we see different behavior between the two.

[bitzoic]

Sorry correction, any case where we are checking for equal will not evaluate to true or false. Checking for not equal will provide the opposite.

This is a minimal repo:

use std::string::String;
use std::assert::assert_eq;
use std::assert::assert;

pub fn test_1<T>(gen_1: T, gen_2: T) -> bool where T: Eq {
    // This evaluate the opposite
    gen_1 != gen_2
}

pub fn test_2<T>(gen_1: T, gen_2: T) -> bool where T: Eq {
    // This evaluates to Failing call to `std::assert::assert`
    gen_1 == gen_2
}

pub fn test_3<T>(gen_1: T, gen_2: T) -> bool where T: Eq {
    // This evaluate the opposite
    if (gen_1 != gen_2) {
        return false;
    }
    return true;
}

pub fn test_4<T>(gen_1: T, gen_2: T) -> bool where T: Eq {
    // This has an internal compiler error
    if (gen_1 == gen_2) {
        return true;
    }
    return false;
}

#[test]
fn foo() {
    let string_a = String::from_ascii_str("Hello World");
    assert_eq(string_a.as_bytes().len(), 11);

    let string_b = String::from_ascii_str("NoNoNo");
    assert_eq(string_b.as_bytes().len(), 6);

    // Should eval to true
    assert(false == test_1(string_a.as_bytes(), string_b.as_bytes()));

    // Should eval to false
    // This evaluates to Failing call to `std::assert::assert` 
    // Will not pass either case but compiles
    assert(false == test_2(string_a.as_bytes(), string_b.as_bytes()));

    // Should eval to false
    assert(true == test_3(string_a.as_bytes(), string_b.as_bytes()));

    // Should eval to false
    // Internal compiler error: Verification failed: Expression used for conditional is not a boolean.
    assert(true == test_4(string_a.as_bytes(), string_b.as_bytes()));
}

[vaivaswatha]

I triaged this a little bit and it appears to be the same problem that is seen in #4770.