Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Remove horrible hack #1951

Merged
merged 1 commit into from
Jul 19, 2023
Merged

Remove horrible hack #1951

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
37 changes: 0 additions & 37 deletions crates/fj-core/src/storage/handle.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -219,61 +219,24 @@ impl<T> Eq for HandleWrapper<T> {}

impl<T> PartialEq for HandleWrapper<T> {
fn eq(&self, other: &Self) -> bool {
// The purpose of `HandleWrapper` is to provide equality (and other
// traits) for `Handle<T>`s that would otherwise not have them. We use
// `Handle::id` to do this. This means, objects that are not identical
// are not equal.
//
// This is desirable for the most part, but it does become horribly
// inconvenient in test code. Tests, by design, create equal (but not
// identical) objects and compare them against objects produced by the
// code under test. Under such a use case, one would rather ignore any
// objects wrapped by `HandleWrapper`.
//
// And the following bit of code does just that. This might be a
// horrible hack that will comes back to bite us later (I honestly don't
// know), but it is certainly a very economical solution to this
// problem.
if cfg!(test) {
return true;
}

self.0.id().eq(&other.0.id())
}
}

impl<T> Hash for HandleWrapper<T> {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
// This piece of code exists to keep this implementation in sync with
// the `PartialEq` implementation. See comment there.
if cfg!(test) {
return;
}

self.0.id().hash(state);
}
}

impl<T> Ord for HandleWrapper<T> {
fn cmp(&self, other: &Self) -> Ordering {
// This piece of code exists to keep this implementation in sync with
// the `PartialEq` implementation. See comment there.
if cfg!(test) {
return Ordering::Equal;
}

self.0.id().cmp(&other.0.id())
}
}

impl<T> PartialOrd for HandleWrapper<T> {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
// This piece of code exists to keep this implementation in sync with
// the `PartialEq` implementation. See comment there.
if cfg!(test) {
return Some(Ordering::Equal);
}

self.0.id().partial_cmp(&other.0.id())
}
}
Expand Down