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

Jump to bottom

ir: Make Ord and PartialOrd implementations agree. #1627

Merged
merged 1 commit into from Sep 23, 2019
Merged

ir: Make Ord and PartialOrd implementations agree. #1627

Show file tree
Hide file tree
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.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
27 changes: 6 additions & 21 deletions src/ir/analysis/has_vtable.rs
View file
Open in desktop
Expand Up @@ -9,17 +9,17 @@ use std::ops;
use {Entry, HashMap};

/// The result of the `HasVtableAnalysis` for an individual item.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum HasVtableResult {
/// The item has a vtable, but the actual vtable pointer is in a base
/// member.
BaseHasVtable,
/// The item does not have a vtable pointer.
No,

/// The item has a vtable and the actual vtable pointer is within this item.
SelfHasVtable,

/// The item does not have a vtable pointer.
No,
/// The item has a vtable, but the actual vtable pointer is in a base
/// member.
BaseHasVtable,
}

impl Default for HasVtableResult {
Expand All @@ -28,21 +28,6 @@ impl Default for HasVtableResult {
}
}

impl cmp::PartialOrd for HasVtableResult {
fn partial_cmp(&self, rhs: &Self) -> Option<cmp::Ordering> {
use self::HasVtableResult::*;

match (*self, *rhs) {
(x, y) if x == y => Some(cmp::Ordering::Equal),
(BaseHasVtable, _) => Some(cmp::Ordering::Greater),
(_, BaseHasVtable) => Some(cmp::Ordering::Less),
(SelfHasVtable, _) => Some(cmp::Ordering::Greater),
(_, SelfHasVtable) => Some(cmp::Ordering::Less),
_ => unreachable!(),
}
}
}

impl HasVtableResult {
/// Take the least upper bound of `self` and `rhs`.
pub fn join(self, rhs: Self) -> Self {
Expand Down
39 changes: 12 additions & 27 deletions src/ir/analysis/sizedness.rs
View file
Open in desktop
Expand Up @@ -24,13 +24,14 @@ use {Entry, HashMap};
///
/// We initially assume that all types are `ZeroSized` and then update our
/// understanding as we learn more about each type.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum SizednessResult {
/// Has some size that is known to be greater than zero. That doesn't mean
/// it has a static size, but it is not zero sized for sure. In other words,
/// it might contain an incomplete array or some other dynamically sized
/// type.
NonZeroSized,
/// The type is zero-sized.
///
/// This means that if it is a C++ type, and is not being used as a base
/// member, then we must add an `_address` byte to enforce the
/// unique-address-per-distinct-object-instance rule.
ZeroSized,

/// Whether this type is zero-sized or not depends on whether a type
/// parameter is zero-sized or not.
Expand All @@ -54,12 +55,11 @@ pub enum SizednessResult {
/// https://github.com/rust-lang/rust-bindgen/issues/586
DependsOnTypeParam,

/// The type is zero-sized.
///
/// This means that if it is a C++ type, and is not being used as a base
/// member, then we must add an `_address` byte to enforce the
/// unique-address-per-distinct-object-instance rule.
ZeroSized,
/// Has some size that is known to be greater than zero. That doesn't mean
/// it has a static size, but it is not zero sized for sure. In other words,
/// it might contain an incomplete array or some other dynamically sized
/// type.
NonZeroSized,
}

impl Default for SizednessResult {
Expand All @@ -68,21 +68,6 @@ impl Default for SizednessResult {
}
}

impl cmp::PartialOrd for SizednessResult {
fn partial_cmp(&self, rhs: &Self) -> Option<cmp::Ordering> {
use self::SizednessResult::*;

match (*self, *rhs) {
(x, y) if x == y => Some(cmp::Ordering::Equal),
(NonZeroSized, _) => Some(cmp::Ordering::Greater),
(_, NonZeroSized) => Some(cmp::Ordering::Less),
(DependsOnTypeParam, _) => Some(cmp::Ordering::Greater),
(_, DependsOnTypeParam) => Some(cmp::Ordering::Less),
_ => unreachable!(),
}
}
}

impl SizednessResult {
/// Take the least upper bound of `self` and `rhs`.
pub fn join(self, rhs: Self) -> Self {
Expand Down
26 changes: 5 additions & 21 deletions src/ir/derive.rs
View file
Open in desktop
Expand Up @@ -92,19 +92,19 @@ pub trait CanDeriveOrd {
///
/// Initially we assume that we can derive trait for all types and then
/// update our understanding as we learn more about each type.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum CanDerive {
/// No, we cannot.
No,
/// Yes, we can derive automatically.
Yes,

/// The only thing that stops us from automatically deriving is that
/// array with more than maximum number of elements is used.
///
/// This means we probably can "manually" implement such trait.
Manually,

/// Yes, we can derive automatically.
Yes,
/// No, we cannot.
No,
}

impl Default for CanDerive {
Expand All @@ -113,22 +113,6 @@ impl Default for CanDerive {
}
}

impl cmp::PartialOrd for CanDerive {
fn partial_cmp(&self, rhs: &Self) -> Option<cmp::Ordering> {
use self::CanDerive::*;

let ordering = match (*self, *rhs) {
(x, y) if x == y => cmp::Ordering::Equal,
(No, _) => cmp::Ordering::Greater,
(_, No) => cmp::Ordering::Less,
(Manually, _) => cmp::Ordering::Greater,
(_, Manually) => cmp::Ordering::Less,
_ => unreachable!(),
};
Some(ordering)
}
}

impl CanDerive {
/// Take the least upper bound of `self` and `rhs`.
pub fn join(self, rhs: Self) -> Self {
Expand Down