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.. { for level in 0.. {
self.size = level + 1; self.size = level + 1;
self.node[level] = node; self.node[level] = node;
match &pool[node] { match pool[node] {
&NodeData::Inner { size, keys, tree } => { NodeData::Inner { size, keys, tree } => {
// Invariant: `tree[i]` contains keys smaller than // Invariant: `tree[i]` contains keys smaller than
// `keys[i]`, greater or equal to `keys[i-1]`. // `keys[i]`, greater or equal to `keys[i-1]`.
let i = match comp.search(key, &keys[0..size.into()]) { 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; self.entry[level] = i as u8;
node = tree[i]; 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. // For a leaf we want either the found key or an insert position.
return match comp.search(key, &keys.borrow()[0..size.into()]) { return match comp.search(key, &keys.borrow()[0..size.into()]) {
Ok(i) => { 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!(); unreachable!();
@@ -94,10 +94,10 @@ impl<F: Forest> Path<F> {
self.size = level + 1; self.size = level + 1;
self.node[level] = node; self.node[level] = node;
self.entry[level] = 0; self.entry[level] = 0;
match &pool[node] { match pool[node] {
&NodeData::Inner { tree, .. } => node = tree[0], NodeData::Inner { tree, .. } => node = tree[0],
&NodeData::Leaf { keys, vals, .. } => return (keys.borrow()[0], vals.borrow()[0]), NodeData::Leaf { keys, vals, .. } => return (keys.borrow()[0], vals.borrow()[0]),
&NodeData::Free { .. } => panic!("Free {} reached from {}", node, root), NodeData::Free { .. } => panic!("Free {} reached from {}", node, root),
} }
} }
unreachable!(); unreachable!();
@@ -205,17 +205,17 @@ impl<F: Forest> Path<F> {
let mut node = root; let mut node = root;
for l in level.. { for l in level.. {
self.node[l] = node; self.node[l] = node;
match &pool[node] { match pool[node] {
&NodeData::Inner { size, ref tree, .. } => { NodeData::Inner { size, ref tree, .. } => {
self.entry[l] = size; self.entry[l] = size;
node = tree[usize::from(size)]; node = tree[usize::from(size)];
} }
&NodeData::Leaf { size, .. } => { NodeData::Leaf { size, .. } => {
self.entry[l] = size - 1; self.entry[l] = size - 1;
self.size = l + 1; self.size = l + 1;
break; break;
} }
&NodeData::Free { .. } => panic!("Free {} reached from {}", node, root), NodeData::Free { .. } => panic!("Free {} reached from {}", node, root),
} }
} }
node node
@@ -405,8 +405,8 @@ impl<F: Forest> Path<F> {
let crit_key = pool[self.leaf_node()].leaf_crit_key(); let crit_key = pool[self.leaf_node()].leaf_crit_key();
let crit_node = self.node[crit_level]; let crit_node = self.node[crit_level];
match &mut pool[crit_node] { match pool[crit_node] {
&mut NodeData::Inner { size, ref mut keys, .. } => { NodeData::Inner { size, ref mut keys, .. } => {
debug_assert!(crit_kidx < size); debug_assert!(crit_kidx < size);
keys[usize::from(crit_kidx)] = crit_key; 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. /// 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> { fn right_sibling_branch_level(&self, level: usize, pool: &NodePool<F>) -> Option<usize> {
(0..level).rposition(|l| match &pool[self.node[l]] { (0..level).rposition(|l| match pool[self.node[l]] {
&NodeData::Inner { size, .. } => self.entry[l] < size, NodeData::Inner { size, .. } => self.entry[l] < size,
_ => panic!("Expected inner node"), _ => panic!("Expected inner node"),
}) })
} }
@@ -622,8 +622,8 @@ impl<F: Forest> Path<F> {
let bl = self.right_sibling_branch_level(level, pool).expect( let bl = self.right_sibling_branch_level(level, pool).expect(
"No right sibling exists", "No right sibling exists",
); );
match &mut pool[self.node[bl]] { match pool[self.node[bl]] {
&mut NodeData::Inner { ref mut keys, .. } => { NodeData::Inner { ref mut keys, .. } => {
keys[usize::from(self.entry[bl])] = crit_key; keys[usize::from(self.entry[bl])] = crit_key;
} }
_ => panic!("Expected inner node"), _ => panic!("Expected inner node"),
@@ -647,8 +647,8 @@ impl<F: Forest> Path<F> {
/// Check the internal consistency of this path. /// Check the internal consistency of this path.
pub fn verify(&self, pool: &NodePool<F>) { pub fn verify(&self, pool: &NodePool<F>) {
for level in 0..self.size { for level in 0..self.size {
match &pool[self.node[level]] { match pool[self.node[level]] {
&NodeData::Inner { size, tree, .. } => { NodeData::Inner { size, tree, .. } => {
assert!( assert!(
level < self.size - 1, level < self.size - 1,
"Expected leaf node at level {}", "Expected leaf node at level {}",
@@ -668,7 +668,7 @@ impl<F: Forest> Path<F> {
level level
); );
} }
&NodeData::Leaf { size, .. } => { NodeData::Leaf { size, .. } => {
assert_eq!(level, self.size - 1, "Expected inner node"); assert_eq!(level, self.size - 1, "Expected inner node");
assert!( assert!(
self.entry[level] <= size, self.entry[level] <= size,
@@ -677,7 +677,7 @@ impl<F: Forest> Path<F> {
size, size,
); );
} }
&NodeData::Free { .. } => { NodeData::Free { .. } => {
panic!("Free {} in path", self.node[level]); 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; let mut lower = lkey;
match &self[node] { match self[node] {
&NodeData::Inner { size, keys, tree } => { NodeData::Inner { size, keys, tree } => {
let size = size as usize; let size = size as usize;
let capacity = tree.len(); let capacity = tree.len();
let keys = &keys[0..size]; let keys = &keys[0..size];
@@ -147,7 +147,7 @@ impl<F: Forest> NodePool<F> {
lower = upper; lower = upper;
} }
} }
&NodeData::Leaf { size, keys, .. } => { NodeData::Leaf { size, keys, .. } => {
let size = size as usize; let size = size as usize;
let capacity = keys.borrow().len(); let capacity = keys.borrow().len();
let keys = &keys.borrow()[0..size]; let keys = &keys.borrow()[0..size];
@@ -190,7 +190,7 @@ impl<F: Forest> NodePool<F> {
lower = upper; 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, DivRemByConstInfo::RemS64(_, _) => true,
}; };
match divrem_info { match *divrem_info {
// -------------------- U32 -------------------- // -------------------- U32 --------------------
// U32 div, rem by zero: ignore // U32 div, rem by zero: ignore
&DivRemByConstInfo::DivU32(_n1, 0) | DivRemByConstInfo::DivU32(_n1, 0) |
&DivRemByConstInfo::RemU32(_n1, 0) => {} DivRemByConstInfo::RemU32(_n1, 0) => {}
// U32 div by 1: identity // U32 div by 1: identity
// U32 rem by 1: zero // U32 rem by 1: zero
&DivRemByConstInfo::DivU32(n1, 1) | DivRemByConstInfo::DivU32(n1, 1) |
&DivRemByConstInfo::RemU32(n1, 1) => { DivRemByConstInfo::RemU32(n1, 1) => {
if isRem { if isRem {
pos.func.dfg.replace(inst).iconst(I32, 0); pos.func.dfg.replace(inst).iconst(I32, 0);
} else { } else {
@@ -190,8 +190,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
} }
// U32 div, rem by a power-of-2 // U32 div, rem by a power-of-2
&DivRemByConstInfo::DivU32(n1, d) | DivRemByConstInfo::DivU32(n1, d) |
&DivRemByConstInfo::RemU32(n1, d) if d.is_power_of_two() => { DivRemByConstInfo::RemU32(n1, d) if d.is_power_of_two() => {
debug_assert!(d >= 2); debug_assert!(d >= 2);
// compute k where d == 2^k // compute k where d == 2^k
let k = d.trailing_zeros(); 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 // U32 div, rem by non-power-of-2
&DivRemByConstInfo::DivU32(n1, d) | DivRemByConstInfo::DivU32(n1, d) |
&DivRemByConstInfo::RemU32(n1, d) => { DivRemByConstInfo::RemU32(n1, d) => {
debug_assert!(d >= 3); debug_assert!(d >= 3);
let MU32 { let MU32 {
mulBy, mulBy,
@@ -247,13 +247,13 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
// -------------------- U64 -------------------- // -------------------- U64 --------------------
// U64 div, rem by zero: ignore // U64 div, rem by zero: ignore
&DivRemByConstInfo::DivU64(_n1, 0) | DivRemByConstInfo::DivU64(_n1, 0) |
&DivRemByConstInfo::RemU64(_n1, 0) => {} DivRemByConstInfo::RemU64(_n1, 0) => {}
// U64 div by 1: identity // U64 div by 1: identity
// U64 rem by 1: zero // U64 rem by 1: zero
&DivRemByConstInfo::DivU64(n1, 1) | DivRemByConstInfo::DivU64(n1, 1) |
&DivRemByConstInfo::RemU64(n1, 1) => { DivRemByConstInfo::RemU64(n1, 1) => {
if isRem { if isRem {
pos.func.dfg.replace(inst).iconst(I64, 0); pos.func.dfg.replace(inst).iconst(I64, 0);
} else { } else {
@@ -262,8 +262,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
} }
// U64 div, rem by a power-of-2 // U64 div, rem by a power-of-2
&DivRemByConstInfo::DivU64(n1, d) | DivRemByConstInfo::DivU64(n1, d) |
&DivRemByConstInfo::RemU64(n1, d) if d.is_power_of_two() => { DivRemByConstInfo::RemU64(n1, d) if d.is_power_of_two() => {
debug_assert!(d >= 2); debug_assert!(d >= 2);
// compute k where d == 2^k // compute k where d == 2^k
let k = d.trailing_zeros(); 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 // U64 div, rem by non-power-of-2
&DivRemByConstInfo::DivU64(n1, d) | DivRemByConstInfo::DivU64(n1, d) |
&DivRemByConstInfo::RemU64(n1, d) => { DivRemByConstInfo::RemU64(n1, d) => {
debug_assert!(d >= 3); debug_assert!(d >= 3);
let MU64 { let MU64 {
mulBy, mulBy,
@@ -319,15 +319,15 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
// -------------------- S32 -------------------- // -------------------- S32 --------------------
// S32 div, rem by zero or -1: ignore // S32 div, rem by zero or -1: ignore
&DivRemByConstInfo::DivS32(_n1, -1) | DivRemByConstInfo::DivS32(_n1, -1) |
&DivRemByConstInfo::RemS32(_n1, -1) | DivRemByConstInfo::RemS32(_n1, -1) |
&DivRemByConstInfo::DivS32(_n1, 0) | DivRemByConstInfo::DivS32(_n1, 0) |
&DivRemByConstInfo::RemS32(_n1, 0) => {} DivRemByConstInfo::RemS32(_n1, 0) => {}
// S32 div by 1: identity // S32 div by 1: identity
// S32 rem by 1: zero // S32 rem by 1: zero
&DivRemByConstInfo::DivS32(n1, 1) | DivRemByConstInfo::DivS32(n1, 1) |
&DivRemByConstInfo::RemS32(n1, 1) => { DivRemByConstInfo::RemS32(n1, 1) => {
if isRem { if isRem {
pos.func.dfg.replace(inst).iconst(I32, 0); pos.func.dfg.replace(inst).iconst(I32, 0);
} else { } else {
@@ -335,8 +335,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
} }
} }
&DivRemByConstInfo::DivS32(n1, d) | DivRemByConstInfo::DivS32(n1, d) |
&DivRemByConstInfo::RemS32(n1, d) => { DivRemByConstInfo::RemS32(n1, d) => {
if let Some((isNeg, k)) = isPowerOf2_S32(d) { if let Some((isNeg, k)) = isPowerOf2_S32(d) {
// k can be 31 only in the case that d is -2^31. // k can be 31 only in the case that d is -2^31.
debug_assert!(k >= 1 && k <= 31); debug_assert!(k >= 1 && k <= 31);
@@ -396,15 +396,15 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
// -------------------- S64 -------------------- // -------------------- S64 --------------------
// S64 div, rem by zero or -1: ignore // S64 div, rem by zero or -1: ignore
&DivRemByConstInfo::DivS64(_n1, -1) | DivRemByConstInfo::DivS64(_n1, -1) |
&DivRemByConstInfo::RemS64(_n1, -1) | DivRemByConstInfo::RemS64(_n1, -1) |
&DivRemByConstInfo::DivS64(_n1, 0) | DivRemByConstInfo::DivS64(_n1, 0) |
&DivRemByConstInfo::RemS64(_n1, 0) => {} DivRemByConstInfo::RemS64(_n1, 0) => {}
// S64 div by 1: identity // S64 div by 1: identity
// S64 rem by 1: zero // S64 rem by 1: zero
&DivRemByConstInfo::DivS64(n1, 1) | DivRemByConstInfo::DivS64(n1, 1) |
&DivRemByConstInfo::RemS64(n1, 1) => { DivRemByConstInfo::RemS64(n1, 1) => {
if isRem { if isRem {
pos.func.dfg.replace(inst).iconst(I64, 0); pos.func.dfg.replace(inst).iconst(I64, 0);
} else { } else {
@@ -412,8 +412,8 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
} }
} }
&DivRemByConstInfo::DivS64(n1, d) | DivRemByConstInfo::DivS64(n1, d) |
&DivRemByConstInfo::RemS64(n1, d) => { DivRemByConstInfo::RemS64(n1, d) => {
if let Some((isNeg, k)) = isPowerOf2_S64(d) { if let Some((isNeg, k)) = isPowerOf2_S64(d) {
// k can be 63 only in the case that d is -2^63. // k can be 63 only in the case that d is -2^63.
debug_assert!(k >= 1 && k <= 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 /// Check if a detail is a Detail::Preset. Useful because the Descriptor
/// offset field has a different meaning when the detail is a preset. /// offset field has a different meaning when the detail is a preset.
pub fn is_preset(&self) -> bool { pub fn is_preset(&self) -> bool {
match self { match *self {
&Detail::Preset => true, Detail::Preset => true,
_ => false, _ => false,
} }
} }