T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Avoid match expressions with reference patterns.

Browse Source 
https://github.com/rust-lang-nursery/rust-clippy/wiki#match_ref_pats
This commit is contained in:
Dan Gohman
2018-03-15 22:38:46 -07:00
parent 99f7cb5b8d
commit 06fe3b654f
4 changed files with 61 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
lib/cretonne/src/bforest/path.rs
View File

@@ -55,8 +55,8 @@ impl<F: Forest> Path<F> {
for level in 0.. {
self.size = level + 1;
self.node[level] = node;
match &pool[node] {
&NodeData::Inner { size, keys, tree } => {
match pool[node] {
NodeData::Inner { size, keys, tree } => {
// Invariant: `tree[i]` contains keys smaller than
// `keys[i]`, greater or equal to `keys[i-1]`.
let i = match comp.search(key, &keys[0..size.into()]) {
@@ -68,7 +68,7 @@ impl<F: Forest> Path<F> {
self.entry[level] = i as u8;
node = tree[i];
}
&NodeData::Leaf { size, keys, vals } => {
NodeData::Leaf { size, keys, vals } => {
// For a leaf we want either the found key or an insert position.
return match comp.search(key, &keys.borrow()[0..size.into()]) {
Ok(i) => {
@@ -81,7 +81,7 @@ impl<F: Forest> Path<F> {
}
};
}
&NodeData::Free { .. } => panic!("Free {} reached from {}", node, root),
NodeData::Free { .. } => panic!("Free {} reached from {}", node, root),
}
}
unreachable!();
@@ -94,10 +94,10 @@ impl<F: Forest> Path<F> {
self.size = level + 1;
self.node[level] = node;
self.entry[level] = 0;
match &pool[node] {
&NodeData::Inner { tree, .. } => node = tree[0],
&NodeData::Leaf { keys, vals, .. } => return (keys.borrow()[0], vals.borrow()[0]),
&NodeData::Free { .. } => panic!("Free {} reached from {}", node, root),
match pool[node] {
NodeData::Inner { tree, .. } => node = tree[0],
NodeData::Leaf { keys, vals, .. } => return (keys.borrow()[0], vals.borrow()[0]),
NodeData::Free { .. } => panic!("Free {} reached from {}", node, root),
}
}
unreachable!();
@@ -205,17 +205,17 @@ impl<F: Forest> Path<F> {
let mut node = root;
for l in level.. {
self.node[l] = node;
match &pool[node] {
&NodeData::Inner { size, ref tree, .. } => {
match pool[node] {
NodeData::Inner { size, ref tree, .. } => {
self.entry[l] = size;
node = tree[usize::from(size)];
}
&NodeData::Leaf { size, .. } => {
NodeData::Leaf { size, .. } => {
self.entry[l] = size - 1;
self.size = l + 1;
break;
}
&NodeData::Free { .. } => panic!("Free {} reached from {}", node, root),
NodeData::Free { .. } => panic!("Free {} reached from {}", node, root),
}
}
node
@@ -405,8 +405,8 @@ impl<F: Forest> Path<F> {
let crit_key = pool[self.leaf_node()].leaf_crit_key();
let crit_node = self.node[crit_level];
match &mut pool[crit_node] {
&mut NodeData::Inner { size, ref mut keys, .. } => {
match pool[crit_node] {
NodeData::Inner { size, ref mut keys, .. } => {
debug_assert!(crit_kidx < size);
keys[usize::from(crit_kidx)] = crit_key;
}
@@ -581,8 +581,8 @@ impl<F: Forest> Path<F> {
///
/// Returns `None` if the current node is a right-most node so no right sibling exists.
fn right_sibling_branch_level(&self, level: usize, pool: &NodePool<F>) -> Option<usize> {
(0..level).rposition(|l| match &pool[self.node[l]] {
&NodeData::Inner { size, .. } => self.entry[l] < size,
(0..level).rposition(|l| match pool[self.node[l]] {
NodeData::Inner { size, .. } => self.entry[l] < size,
_ => panic!("Expected inner node"),
})
}
@@ -622,8 +622,8 @@ impl<F: Forest> Path<F> {
let bl = self.right_sibling_branch_level(level, pool).expect(
"No right sibling exists",
);
match &mut pool[self.node[bl]] {
&mut NodeData::Inner { ref mut keys, .. } => {
match pool[self.node[bl]] {
NodeData::Inner { ref mut keys, .. } => {
keys[usize::from(self.entry[bl])] = crit_key;
}
_ => panic!("Expected inner node"),
@@ -647,8 +647,8 @@ impl<F: Forest> Path<F> {
/// Check the internal consistency of this path.
pub fn verify(&self, pool: &NodePool<F>) {
for level in 0..self.size {
match &pool[self.node[level]] {
&NodeData::Inner { size, tree, .. } => {
match pool[self.node[level]] {
NodeData::Inner { size, tree, .. } => {
assert!(
level < self.size - 1,
"Expected leaf node at level {}",
@@ -668,7 +668,7 @@ impl<F: Forest> Path<F> {
level
);
}
&NodeData::Leaf { size, .. } => {
NodeData::Leaf { size, .. } => {
assert_eq!(level, self.size - 1, "Expected inner node");
assert!(
self.entry[level] <= size,
@@ -677,7 +677,7 @@ impl<F: Forest> Path<F> {
size,
);
}
&NodeData::Free { .. } => {
NodeData::Free { .. } => {
panic!("Free {} in path", self.node[level]);
}
}

8
lib/cretonne/src/bforest/pool.rs
View File

@@ -104,8 +104,8 @@ impl<F: Forest> NodePool<F> {
);
let mut lower = lkey;
match &self[node] {
&NodeData::Inner { size, keys, tree } => {
match self[node] {
NodeData::Inner { size, keys, tree } => {
let size = size as usize;
let capacity = tree.len();
let keys = &keys[0..size];
@@ -147,7 +147,7 @@ impl<F: Forest> NodePool<F> {
lower = upper;
}
}
&NodeData::Leaf { size, keys, .. } => {
NodeData::Leaf { size, keys, .. } => {
let size = size as usize;
let capacity = keys.borrow().len();
let keys = &keys.borrow()[0..size];
@@ -190,7 +190,7 @@ impl<F: Forest> NodePool<F> {
lower = upper;
}
}
&NodeData::Free { .. } => panic!("Free {} reached", node),
NodeData::Free { .. } => panic!("Free {} reached", node),
}
}
}

66
lib/cretonne/src/preopt.rs
View File

@@ -170,18 +170,18 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
DivRemByConstInfo::RemS64(_, _) => true,
};
match divrem_info {
match *divrem_info {
// -------------------- U32 --------------------
// U32 div, rem by zero: ignore
&DivRemByConstInfo::DivU32(_n1, 0) |
&DivRemByConstInfo::RemU32(_n1, 0) => {}
DivRemByConstInfo::DivU32(_n1, 0) |
DivRemByConstInfo::RemU32(_n1, 0) => {}
// U32 div by 1: identity
// U32 rem by 1: zero
&DivRemByConstInfo::DivU32(n1, 1) |
&DivRemByConstInfo::RemU32(n1, 1) => {
DivRemByConstInfo::DivU32(n1, 1) |
DivRemByConstInfo::RemU32(n1, 1) => {
if isRem {
pos.func.dfg.replace(inst).iconst(I32, 0);
} else {
@@ -190,8 +190,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
}
// U32 div, rem by a power-of-2
&DivRemByConstInfo::DivU32(n1, d) |
&DivRemByConstInfo::RemU32(n1, d) if d.is_power_of_two() => {
DivRemByConstInfo::DivU32(n1, d) |
DivRemByConstInfo::RemU32(n1, d) if d.is_power_of_two() => {
debug_assert!(d >= 2);
// compute k where d == 2^k
let k = d.trailing_zeros();
@@ -205,8 +205,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
}
// U32 div, rem by non-power-of-2
&DivRemByConstInfo::DivU32(n1, d) |
&DivRemByConstInfo::RemU32(n1, d) => {
DivRemByConstInfo::DivU32(n1, d) |
DivRemByConstInfo::RemU32(n1, d) => {
debug_assert!(d >= 3);
let MU32 {
mulBy,
@@ -247,13 +247,13 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
// -------------------- U64 --------------------
// U64 div, rem by zero: ignore
&DivRemByConstInfo::DivU64(_n1, 0) |
&DivRemByConstInfo::RemU64(_n1, 0) => {}
DivRemByConstInfo::DivU64(_n1, 0) |
DivRemByConstInfo::RemU64(_n1, 0) => {}
// U64 div by 1: identity
// U64 rem by 1: zero
&DivRemByConstInfo::DivU64(n1, 1) |
&DivRemByConstInfo::RemU64(n1, 1) => {
DivRemByConstInfo::DivU64(n1, 1) |
DivRemByConstInfo::RemU64(n1, 1) => {
if isRem {
pos.func.dfg.replace(inst).iconst(I64, 0);
} else {
@@ -262,8 +262,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
}
// U64 div, rem by a power-of-2
&DivRemByConstInfo::DivU64(n1, d) |
&DivRemByConstInfo::RemU64(n1, d) if d.is_power_of_two() => {
DivRemByConstInfo::DivU64(n1, d) |
DivRemByConstInfo::RemU64(n1, d) if d.is_power_of_two() => {
debug_assert!(d >= 2);
// compute k where d == 2^k
let k = d.trailing_zeros();
@@ -277,8 +277,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
}
// U64 div, rem by non-power-of-2
&DivRemByConstInfo::DivU64(n1, d) |
&DivRemByConstInfo::RemU64(n1, d) => {
DivRemByConstInfo::DivU64(n1, d) |
DivRemByConstInfo::RemU64(n1, d) => {
debug_assert!(d >= 3);
let MU64 {
mulBy,
@@ -319,15 +319,15 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
// -------------------- S32 --------------------
// S32 div, rem by zero or -1: ignore
&DivRemByConstInfo::DivS32(_n1, -1) |
&DivRemByConstInfo::RemS32(_n1, -1) |
&DivRemByConstInfo::DivS32(_n1, 0) |
&DivRemByConstInfo::RemS32(_n1, 0) => {}
DivRemByConstInfo::DivS32(_n1, -1) |
DivRemByConstInfo::RemS32(_n1, -1) |
DivRemByConstInfo::DivS32(_n1, 0) |
DivRemByConstInfo::RemS32(_n1, 0) => {}
// S32 div by 1: identity
// S32 rem by 1: zero
&DivRemByConstInfo::DivS32(n1, 1) |
&DivRemByConstInfo::RemS32(n1, 1) => {
DivRemByConstInfo::DivS32(n1, 1) |
DivRemByConstInfo::RemS32(n1, 1) => {
if isRem {
pos.func.dfg.replace(inst).iconst(I32, 0);
} else {
@@ -335,8 +335,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
}
}
&DivRemByConstInfo::DivS32(n1, d) |
&DivRemByConstInfo::RemS32(n1, d) => {
DivRemByConstInfo::DivS32(n1, d) |
DivRemByConstInfo::RemS32(n1, d) => {
if let Some((isNeg, k)) = isPowerOf2_S32(d) {
// k can be 31 only in the case that d is -2^31.
debug_assert!(k >= 1 && k <= 31);
@@ -396,15 +396,15 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
// -------------------- S64 --------------------
// S64 div, rem by zero or -1: ignore
&DivRemByConstInfo::DivS64(_n1, -1) |
&DivRemByConstInfo::RemS64(_n1, -1) |
&DivRemByConstInfo::DivS64(_n1, 0) |
&DivRemByConstInfo::RemS64(_n1, 0) => {}
DivRemByConstInfo::DivS64(_n1, -1) |
DivRemByConstInfo::RemS64(_n1, -1) |
DivRemByConstInfo::DivS64(_n1, 0) |
DivRemByConstInfo::RemS64(_n1, 0) => {}
// S64 div by 1: identity
// S64 rem by 1: zero
&DivRemByConstInfo::DivS64(n1, 1) |
&DivRemByConstInfo::RemS64(n1, 1) => {
DivRemByConstInfo::DivS64(n1, 1) |
DivRemByConstInfo::RemS64(n1, 1) => {
if isRem {
pos.func.dfg.replace(inst).iconst(I64, 0);
} else {
@@ -412,8 +412,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
}
}
&DivRemByConstInfo::DivS64(n1, d) |
&DivRemByConstInfo::RemS64(n1, d) => {
DivRemByConstInfo::DivS64(n1, d) |
DivRemByConstInfo::RemS64(n1, d) => {
if let Some((isNeg, k)) = isPowerOf2_S64(d) {
// k can be 63 only in the case that d is -2^63.
debug_assert!(k >= 1 && k <= 63);

4
lib/cretonne/src/settings.rs
View File

@@ -302,8 +302,8 @@ pub mod detail {
/// Check if a detail is a Detail::Preset. Useful because the Descriptor
/// offset field has a different meaning when the detail is a preset.
pub fn is_preset(&self) -> bool {
match self {
&Detail::Preset => true,
match *self {
Detail::Preset => true,
_ => false,
}
}