rollup merge of #22287: Ryman/purge_carthographers
This overlaps with #22276 (I left make check running overnight) but covers a number of additional cases and has a few rewrites where the clones are not even necessary. This also implements `RandomAccessIterator` for `iter::Cloned` cc @steveklabnik, you may want to glance at this before #22281 gets the bors treatment
This commit is contained in:
Alex Crichton
commit
c07ec507e2
48 changed files with 129 additions and 126 deletions
|
|
@ -21,6 +21,7 @@
|
|||
#![feature(test)]
|
||||
#![feature(unicode)]
|
||||
#![feature(env)]
|
||||
#![feature(core)]
|
||||
|
||||
#![deny(warnings)]
|
||||
|
||||
|
|
|
|||
|
|
@ -1134,7 +1134,7 @@ fn compile_test_(config: &Config, props: &TestProps,
|
|||
// FIXME (#9639): This needs to handle non-utf8 paths
|
||||
let mut link_args = vec!("-L".to_string(),
|
||||
aux_dir.as_str().unwrap().to_string());
|
||||
link_args.extend(extra_args.iter().map(|s| s.clone()));
|
||||
link_args.extend(extra_args.iter().cloned());
|
||||
let args = make_compile_args(config,
|
||||
props,
|
||||
link_args,
|
||||
|
|
|
|||
|
|
@ -2286,7 +2286,7 @@ mod tests {
|
|||
#[test]
|
||||
fn test_from_bools() {
|
||||
let bools = vec![true, false, true, true];
|
||||
let bitv: Bitv = bools.iter().map(|n| *n).collect();
|
||||
let bitv: Bitv = bools.iter().cloned().collect();
|
||||
assert_eq!(format!("{:?}", bitv), "1011");
|
||||
}
|
||||
|
||||
|
|
@ -2299,12 +2299,12 @@ mod tests {
|
|||
#[test]
|
||||
fn test_bitv_iterator() {
|
||||
let bools = vec![true, false, true, true];
|
||||
let bitv: Bitv = bools.iter().map(|n| *n).collect();
|
||||
let bitv: Bitv = bools.iter().cloned().collect();
|
||||
|
||||
assert_eq!(bitv.iter().collect::<Vec<bool>>(), bools);
|
||||
|
||||
let long: Vec<_> = (0i32..10000).map(|i| i % 2 == 0).collect();
|
||||
let bitv: Bitv = long.iter().map(|n| *n).collect();
|
||||
let bitv: Bitv = long.iter().cloned().collect();
|
||||
assert_eq!(bitv.iter().collect::<Vec<bool>>(), long)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -907,7 +907,7 @@ impl<A: Ord> Ord for DList<A> {
|
|||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<A: Clone> Clone for DList<A> {
|
||||
fn clone(&self) -> DList<A> {
|
||||
self.iter().map(|x| x.clone()).collect()
|
||||
self.iter().cloned().collect()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1025,7 +1025,7 @@ mod tests {
|
|||
|
||||
#[cfg(test)]
|
||||
fn list_from<T: Clone>(v: &[T]) -> DList<T> {
|
||||
v.iter().map(|x| (*x).clone()).collect()
|
||||
v.iter().cloned().collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -332,7 +332,7 @@ pub trait IteratorExt: Iterator + Sized {
|
|||
///
|
||||
/// ```
|
||||
/// let xs = [100, 200, 300];
|
||||
/// let mut it = xs.iter().map(|x| *x).peekable();
|
||||
/// let mut it = xs.iter().cloned().peekable();
|
||||
/// assert_eq!(*it.peek().unwrap(), 100);
|
||||
/// assert_eq!(it.next().unwrap(), 100);
|
||||
/// assert_eq!(it.next().unwrap(), 200);
|
||||
|
|
@ -522,7 +522,7 @@ pub trait IteratorExt: Iterator + Sized {
|
|||
///
|
||||
/// let a = [1, 4, 2, 3, 8, 9, 6];
|
||||
/// let sum = a.iter()
|
||||
/// .map(|&x| x)
|
||||
/// .cloned()
|
||||
/// .inspect(|&x| println!("filtering {}", x))
|
||||
/// .filter(|&x| x % 2 == 0)
|
||||
/// .inspect(|&x| println!("{} made it through", x))
|
||||
|
|
@ -561,7 +561,7 @@ pub trait IteratorExt: Iterator + Sized {
|
|||
///
|
||||
/// ```
|
||||
/// let a = [1, 2, 3, 4, 5];
|
||||
/// let b: Vec<_> = a.iter().map(|&x| x).collect();
|
||||
/// let b: Vec<_> = a.iter().cloned().collect();
|
||||
/// assert_eq!(a, b);
|
||||
/// ```
|
||||
#[inline]
|
||||
|
|
@ -937,7 +937,7 @@ pub trait IteratorExt: Iterator + Sized {
|
|||
///
|
||||
/// ```
|
||||
/// let a = [(1, 2), (3, 4)];
|
||||
/// let (left, right): (Vec<_>, Vec<_>) = a.iter().map(|&x| x).unzip();
|
||||
/// let (left, right): (Vec<_>, Vec<_>) = a.iter().cloned().unzip();
|
||||
/// assert_eq!([1, 3], left);
|
||||
/// assert_eq!([2, 4], right);
|
||||
/// ```
|
||||
|
|
@ -1142,7 +1142,7 @@ pub trait AdditiveIterator<A> {
|
|||
/// use std::iter::AdditiveIterator;
|
||||
///
|
||||
/// let a = [1i32, 2, 3, 4, 5];
|
||||
/// let mut it = a.iter().map(|&x| x);
|
||||
/// let mut it = a.iter().cloned();
|
||||
/// assert!(it.sum() == 15);
|
||||
/// ```
|
||||
fn sum(self) -> A;
|
||||
|
|
@ -1305,6 +1305,23 @@ impl<T, D, I> ExactSizeIterator for Cloned<I> where
|
|||
I: ExactSizeIterator<Item=D>,
|
||||
{}
|
||||
|
||||
#[unstable(feature = "core", reason = "trait is experimental")]
|
||||
impl<T, D, I> RandomAccessIterator for Cloned<I> where
|
||||
T: Clone,
|
||||
D: Deref<Target=T>,
|
||||
I: RandomAccessIterator<Item=D>
|
||||
{
|
||||
#[inline]
|
||||
fn indexable(&self) -> usize {
|
||||
self.it.indexable()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn idx(&mut self, index: usize) -> Option<T> {
|
||||
self.it.idx(index).cloned()
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator that repeats endlessly
|
||||
#[derive(Clone)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ fn test_iterator_chain() {
|
|||
assert_eq!(i, expected.len());
|
||||
|
||||
let ys = count(30, 10).take(4);
|
||||
let mut it = xs.iter().map(|&x| x).chain(ys);
|
||||
let mut it = xs.iter().cloned().chain(ys);
|
||||
let mut i = 0;
|
||||
for x in it {
|
||||
assert_eq!(x, expected[i]);
|
||||
|
|
@ -119,7 +119,7 @@ fn test_iterator_enumerate() {
|
|||
#[test]
|
||||
fn test_iterator_peekable() {
|
||||
let xs = vec![0, 1, 2, 3, 4, 5];
|
||||
let mut it = xs.iter().map(|&x|x).peekable();
|
||||
let mut it = xs.iter().cloned().peekable();
|
||||
|
||||
assert_eq!(it.len(), 6);
|
||||
assert_eq!(it.peek().unwrap(), &0);
|
||||
|
|
@ -259,7 +259,7 @@ fn test_inspect() {
|
|||
let mut n = 0;
|
||||
|
||||
let ys = xs.iter()
|
||||
.map(|&x| x)
|
||||
.cloned()
|
||||
.inspect(|_| n += 1)
|
||||
.collect::<Vec<uint>>();
|
||||
|
||||
|
|
@ -329,33 +329,33 @@ fn test_iterator_len() {
|
|||
#[test]
|
||||
fn test_iterator_sum() {
|
||||
let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||
assert_eq!(v[..4].iter().map(|&x| x).sum(), 6);
|
||||
assert_eq!(v.iter().map(|&x| x).sum(), 55);
|
||||
assert_eq!(v[..0].iter().map(|&x| x).sum(), 0);
|
||||
assert_eq!(v[..4].iter().cloned().sum(), 6);
|
||||
assert_eq!(v.iter().cloned().sum(), 55);
|
||||
assert_eq!(v[..0].iter().cloned().sum(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_iterator_product() {
|
||||
let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||
assert_eq!(v[..4].iter().map(|&x| x).product(), 0);
|
||||
assert_eq!(v[1..5].iter().map(|&x| x).product(), 24);
|
||||
assert_eq!(v[..0].iter().map(|&x| x).product(), 1);
|
||||
assert_eq!(v[..4].iter().cloned().product(), 0);
|
||||
assert_eq!(v[1..5].iter().cloned().product(), 24);
|
||||
assert_eq!(v[..0].iter().cloned().product(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_iterator_max() {
|
||||
let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||
assert_eq!(v[..4].iter().map(|&x| x).max(), Some(3));
|
||||
assert_eq!(v.iter().map(|&x| x).max(), Some(10));
|
||||
assert_eq!(v[..0].iter().map(|&x| x).max(), None);
|
||||
assert_eq!(v[..4].iter().cloned().max(), Some(3));
|
||||
assert_eq!(v.iter().cloned().max(), Some(10));
|
||||
assert_eq!(v[..0].iter().cloned().max(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_iterator_min() {
|
||||
let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||
assert_eq!(v[..4].iter().map(|&x| x).min(), Some(0));
|
||||
assert_eq!(v.iter().map(|&x| x).min(), Some(0));
|
||||
assert_eq!(v[..0].iter().map(|&x| x).min(), None);
|
||||
assert_eq!(v[..4].iter().cloned().min(), Some(0));
|
||||
assert_eq!(v.iter().cloned().min(), Some(0));
|
||||
assert_eq!(v[..0].iter().cloned().min(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -373,7 +373,7 @@ fn test_iterator_size_hint() {
|
|||
assert_eq!(c.clone().take_while(|_| false).size_hint(), (0, None));
|
||||
assert_eq!(c.clone().skip_while(|_| false).size_hint(), (0, None));
|
||||
assert_eq!(c.clone().enumerate().size_hint(), (uint::MAX, None));
|
||||
assert_eq!(c.clone().chain(vi.clone().map(|&i| i)).size_hint(), (uint::MAX, None));
|
||||
assert_eq!(c.clone().chain(vi.clone().cloned()).size_hint(), (uint::MAX, None));
|
||||
assert_eq!(c.clone().zip(vi.clone()).size_hint(), (10, Some(10)));
|
||||
assert_eq!(c.clone().scan(0, |_,_| Some(0)).size_hint(), (0, None));
|
||||
assert_eq!(c.clone().filter(|_| false).size_hint(), (0, None));
|
||||
|
|
@ -398,7 +398,7 @@ fn test_iterator_size_hint() {
|
|||
#[test]
|
||||
fn test_collect() {
|
||||
let a = vec![1, 2, 3, 4, 5];
|
||||
let b: Vec<int> = a.iter().map(|&x| x).collect();
|
||||
let b: Vec<int> = a.iter().cloned().collect();
|
||||
assert!(a == b);
|
||||
}
|
||||
|
||||
|
|
@ -471,7 +471,7 @@ fn test_rev() {
|
|||
let mut it = xs.iter();
|
||||
it.next();
|
||||
it.next();
|
||||
assert!(it.rev().map(|&x| x).collect::<Vec<int>>() ==
|
||||
assert!(it.rev().cloned().collect::<Vec<int>>() ==
|
||||
vec![16, 14, 12, 10, 8, 6]);
|
||||
}
|
||||
|
||||
|
|
@ -508,7 +508,7 @@ fn test_double_ended_map() {
|
|||
#[test]
|
||||
fn test_double_ended_enumerate() {
|
||||
let xs = [1, 2, 3, 4, 5, 6];
|
||||
let mut it = xs.iter().map(|&x| x).enumerate();
|
||||
let mut it = xs.iter().cloned().enumerate();
|
||||
assert_eq!(it.next(), Some((0, 1)));
|
||||
assert_eq!(it.next(), Some((1, 2)));
|
||||
assert_eq!(it.next_back(), Some((5, 6)));
|
||||
|
|
@ -522,8 +522,8 @@ fn test_double_ended_enumerate() {
|
|||
fn test_double_ended_zip() {
|
||||
let xs = [1, 2, 3, 4, 5, 6];
|
||||
let ys = [1, 2, 3, 7];
|
||||
let a = xs.iter().map(|&x| x);
|
||||
let b = ys.iter().map(|&x| x);
|
||||
let a = xs.iter().cloned();
|
||||
let b = ys.iter().cloned();
|
||||
let mut it = a.zip(b);
|
||||
assert_eq!(it.next(), Some((1, 1)));
|
||||
assert_eq!(it.next(), Some((2, 2)));
|
||||
|
|
@ -713,7 +713,7 @@ fn test_random_access_inspect() {
|
|||
fn test_random_access_map() {
|
||||
let xs = [1, 2, 3, 4, 5];
|
||||
|
||||
let mut it = xs.iter().map(|x| *x);
|
||||
let mut it = xs.iter().cloned();
|
||||
assert_eq!(xs.len(), it.indexable());
|
||||
for (i, elt) in xs.iter().enumerate() {
|
||||
assert_eq!(Some(*elt), it.idx(i));
|
||||
|
|
|
|||
|
|
@ -215,7 +215,7 @@ impl<'a> SeedableRng<&'a [u32]> for IsaacRng {
|
|||
fn reseed(&mut self, seed: &'a [u32]) {
|
||||
// make the seed into [seed[0], seed[1], ..., seed[seed.len()
|
||||
// - 1], 0, 0, ...], to fill rng.rsl.
|
||||
let seed_iter = seed.iter().map(|&x| x).chain(repeat(0u32));
|
||||
let seed_iter = seed.iter().cloned().chain(repeat(0u32));
|
||||
|
||||
for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) {
|
||||
*rsl_elem = seed_elem;
|
||||
|
|
@ -458,7 +458,7 @@ impl<'a> SeedableRng<&'a [u64]> for Isaac64Rng {
|
|||
fn reseed(&mut self, seed: &'a [u64]) {
|
||||
// make the seed into [seed[0], seed[1], ..., seed[seed.len()
|
||||
// - 1], 0, 0, ...], to fill rng.rsl.
|
||||
let seed_iter = seed.iter().map(|&x| x).chain(repeat(0u64));
|
||||
let seed_iter = seed.iter().cloned().chain(repeat(0u64));
|
||||
|
||||
for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) {
|
||||
*rsl_elem = seed_elem;
|
||||
|
|
|
|||
|
|
@ -139,8 +139,7 @@ impl CStore {
|
|||
pub fn get_used_crate_source(&self, cnum: ast::CrateNum)
|
||||
-> Option<CrateSource> {
|
||||
self.used_crate_sources.borrow_mut()
|
||||
.iter().find(|source| source.cnum == cnum)
|
||||
.map(|source| source.clone())
|
||||
.iter().find(|source| source.cnum == cnum).cloned()
|
||||
}
|
||||
|
||||
pub fn reset(&self) {
|
||||
|
|
@ -218,7 +217,7 @@ impl CStore {
|
|||
|
||||
pub fn find_extern_mod_stmt_cnum(&self, emod_id: ast::NodeId)
|
||||
-> Option<ast::CrateNum> {
|
||||
self.extern_mod_crate_map.borrow().get(&emod_id).map(|x| *x)
|
||||
self.extern_mod_crate_map.borrow().get(&emod_id).cloned()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ impl<'a> fmt::Debug for Matrix<'a> {
|
|||
pretty_printed_matrix.iter().map(|row| row[col].len()).max().unwrap_or(0)
|
||||
}).collect();
|
||||
|
||||
let total_width = column_widths.iter().map(|n| *n).sum() + column_count * 3 + 1;
|
||||
let total_width = column_widths.iter().cloned().sum() + column_count * 3 + 1;
|
||||
let br = repeat('+').take(total_width).collect::<String>();
|
||||
try!(write!(f, "{}\n", br));
|
||||
for row in pretty_printed_matrix {
|
||||
|
|
|
|||
|
|
@ -501,7 +501,7 @@ fn lit_to_const(lit: &ast::Lit, ty_hint: Option<Ty>) -> const_val {
|
|||
match lit.node {
|
||||
ast::LitStr(ref s, _) => const_str((*s).clone()),
|
||||
ast::LitBinary(ref data) => {
|
||||
const_binary(Rc::new(data.iter().map(|x| *x).collect()))
|
||||
const_binary(data.clone())
|
||||
}
|
||||
ast::LitByte(n) => const_uint(n as u64),
|
||||
ast::LitChar(n) => const_uint(n as u64),
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ struct PropagationContext<'a, 'b: 'a, 'tcx: 'b, O: 'a> {
|
|||
}
|
||||
|
||||
fn to_cfgidx_or_die(id: ast::NodeId, index: &NodeMap<CFGIndex>) -> CFGIndex {
|
||||
let opt_cfgindex = index.get(&id).map(|&i|i);
|
||||
let opt_cfgindex = index.get(&id).cloned();
|
||||
opt_cfgindex.unwrap_or_else(|| {
|
||||
panic!("nodeid_to_index does not have entry for NodeId {}", id);
|
||||
})
|
||||
|
|
@ -400,7 +400,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
|
|||
|
||||
let mut changed = false;
|
||||
for &node_id in &edge.data.exiting_scopes {
|
||||
let opt_cfg_idx = self.nodeid_to_index.get(&node_id).map(|&i|i);
|
||||
let opt_cfg_idx = self.nodeid_to_index.get(&node_id).cloned();
|
||||
match opt_cfg_idx {
|
||||
Some(cfg_idx) => {
|
||||
let (start, end) = self.compute_id_range(cfg_idx);
|
||||
|
|
|
|||
|
|
@ -158,7 +158,7 @@ fn calculate_type(sess: &session::Session,
|
|||
|
||||
// Collect what we've got so far in the return vector.
|
||||
let mut ret = (1..sess.cstore.next_crate_num()).map(|i| {
|
||||
match formats.get(&i).map(|v| *v) {
|
||||
match formats.get(&i).cloned() {
|
||||
v @ Some(cstore::RequireDynamic) => v,
|
||||
_ => None,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -924,7 +924,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
|
|||
|
||||
fn rebuild(&self)
|
||||
-> (ast::FnDecl, Option<ast::ExplicitSelf_>, ast::Generics) {
|
||||
let mut expl_self_opt = self.expl_self_opt.map(|x| x.clone());
|
||||
let mut expl_self_opt = self.expl_self_opt.cloned();
|
||||
let mut inputs = self.fn_decl.inputs.clone();
|
||||
let mut output = self.fn_decl.output.clone();
|
||||
let mut ty_params = self.generics.ty_params.clone();
|
||||
|
|
|
|||
|
|
@ -147,18 +147,12 @@ struct LanguageItemCollector<'a> {
|
|||
|
||||
impl<'a, 'v> Visitor<'v> for LanguageItemCollector<'a> {
|
||||
fn visit_item(&mut self, item: &ast::Item) {
|
||||
match extract(&item.attrs) {
|
||||
Some(value) => {
|
||||
let item_index = self.item_refs.get(&value[]).map(|x| *x);
|
||||
if let Some(value) = extract(&item.attrs) {
|
||||
let item_index = self.item_refs.get(&value[]).cloned();
|
||||
|
||||
match item_index {
|
||||
Some(item_index) => {
|
||||
self.collect_item(item_index, local_def(item.id), item.span)
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
if let Some(item_index) = item_index {
|
||||
self.collect_item(item_index, local_def(item.id), item.span)
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
|
||||
visit::walk_item(self, item);
|
||||
|
|
|
|||
|
|
@ -407,7 +407,7 @@ impl RegionMaps {
|
|||
|
||||
pub fn opt_encl_scope(&self, id: CodeExtent) -> Option<CodeExtent> {
|
||||
//! Returns the narrowest scope that encloses `id`, if any.
|
||||
self.scope_map.borrow().get(&id).map(|x| *x)
|
||||
self.scope_map.borrow().get(&id).cloned()
|
||||
}
|
||||
|
||||
#[allow(dead_code)] // used in middle::cfg
|
||||
|
|
|
|||
|
|
@ -562,7 +562,7 @@ pub fn early_bound_lifetimes<'a>(generics: &'a ast::Generics) -> Vec<ast::Lifeti
|
|||
|
||||
generics.lifetimes.iter()
|
||||
.filter(|l| referenced_idents.iter().any(|&i| i == l.lifetime.name))
|
||||
.map(|l| (*l).clone())
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ impl<'tcx> Substs<'tcx> {
|
|||
}
|
||||
|
||||
pub fn self_ty(&self) -> Option<Ty<'tcx>> {
|
||||
self.types.get_self().map(|&t| t)
|
||||
self.types.get_self().cloned()
|
||||
}
|
||||
|
||||
pub fn with_self_ty(&self, self_ty: Ty<'tcx>) -> Substs<'tcx> {
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ pub fn is_object_safe<'tcx>(tcx: &ty::ctxt<'tcx>,
|
|||
{
|
||||
// Because we query yes/no results frequently, we keep a cache:
|
||||
let cached_result =
|
||||
tcx.object_safety_cache.borrow().get(&trait_ref.def_id()).map(|&r| r);
|
||||
tcx.object_safety_cache.borrow().get(&trait_ref.def_id()).cloned();
|
||||
|
||||
let result =
|
||||
cached_result.unwrap_or_else(|| {
|
||||
|
|
|
|||
|
|
@ -738,7 +738,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
|
|||
{
|
||||
let cache = self.pick_candidate_cache();
|
||||
let hashmap = cache.hashmap.borrow();
|
||||
hashmap.get(&cache_fresh_trait_pred.0.trait_ref).map(|c| (*c).clone())
|
||||
hashmap.get(&cache_fresh_trait_pred.0.trait_ref).cloned()
|
||||
}
|
||||
|
||||
fn insert_candidate_cache(&mut self,
|
||||
|
|
@ -1565,7 +1565,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
|
|||
ty::substd_enum_variants(self.tcx(), def_id, substs)
|
||||
.iter()
|
||||
.flat_map(|variant| variant.args.iter())
|
||||
.map(|&ty| ty)
|
||||
.cloned()
|
||||
.collect();
|
||||
nominal(self, bound, def_id, types)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2832,7 +2832,7 @@ pub fn mk_ctor_fn<'tcx>(cx: &ctxt<'tcx>,
|
|||
def_id: ast::DefId,
|
||||
input_tys: &[Ty<'tcx>],
|
||||
output: Ty<'tcx>) -> Ty<'tcx> {
|
||||
let input_args = input_tys.iter().map(|ty| *ty).collect();
|
||||
let input_args = input_tys.iter().cloned().collect();
|
||||
mk_bare_fn(cx,
|
||||
Some(def_id),
|
||||
cx.mk_bare_fn(BareFnTy {
|
||||
|
|
@ -3801,7 +3801,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>)
|
|||
-> Representability {
|
||||
match ty.sty {
|
||||
ty_tup(ref ts) => {
|
||||
find_nonrepresentable(cx, sp, seen, ts.iter().map(|ty| *ty))
|
||||
find_nonrepresentable(cx, sp, seen, ts.iter().cloned())
|
||||
}
|
||||
// Fixed-length vectors.
|
||||
// FIXME(#11924) Behavior undecided for zero-length vectors.
|
||||
|
|
@ -4108,7 +4108,7 @@ pub fn positional_element_ty<'tcx>(cx: &ctxt<'tcx>,
|
|||
variant: Option<ast::DefId>) -> Option<Ty<'tcx>> {
|
||||
|
||||
match (&ty.sty, variant) {
|
||||
(&ty_tup(ref v), None) => v.get(i).map(|&t| t),
|
||||
(&ty_tup(ref v), None) => v.get(i).cloned(),
|
||||
|
||||
|
||||
(&ty_struct(def_id, substs), None) => lookup_struct_fields(cx, def_id)
|
||||
|
|
@ -4929,7 +4929,7 @@ pub fn note_and_explain_type_err(cx: &ctxt, err: &type_err) {
|
|||
}
|
||||
|
||||
pub fn provided_source(cx: &ctxt, id: ast::DefId) -> Option<ast::DefId> {
|
||||
cx.provided_method_sources.borrow().get(&id).map(|x| *x)
|
||||
cx.provided_method_sources.borrow().get(&id).cloned()
|
||||
}
|
||||
|
||||
pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId)
|
||||
|
|
@ -6600,7 +6600,7 @@ pub fn accumulate_lifetimes_in_type(accumulator: &mut Vec<ty::Region>,
|
|||
}
|
||||
|
||||
/// A free variable referred to in a function.
|
||||
#[derive(Copy, RustcEncodable, RustcDecodable)]
|
||||
#[derive(Copy, Clone, RustcEncodable, RustcDecodable)]
|
||||
pub struct Freevar {
|
||||
/// The variable being accessed free.
|
||||
pub def: def::Def,
|
||||
|
|
|
|||
|
|
@ -214,7 +214,7 @@ pub fn memoized<T, U, S, F>(cache: &RefCell<HashMap<T, U, S>>, arg: T, f: F) ->
|
|||
F: FnOnce(T) -> U,
|
||||
{
|
||||
let key = arg.clone();
|
||||
let result = cache.borrow().get(&key).map(|result| result.clone());
|
||||
let result = cache.borrow().get(&key).cloned();
|
||||
match result {
|
||||
Some(result) => result,
|
||||
None => {
|
||||
|
|
|
|||
|
|
@ -40,10 +40,7 @@ pub fn get_rpath_flags<F, G>(config: RPathConfig<F, G>) -> Vec<String> where
|
|||
debug!("preparing the RPATH!");
|
||||
|
||||
let libs = config.used_crates.clone();
|
||||
let libs = libs.into_iter().filter_map(|(_, l)| {
|
||||
l.map(|p| p.clone())
|
||||
}).collect::<Vec<_>>();
|
||||
|
||||
let libs = libs.into_iter().filter_map(|(_, l)| l).collect::<Vec<_>>();
|
||||
let rpaths = get_rpaths(config, &libs[]);
|
||||
flags.push_all(&rpaths_to_flags(&rpaths[])[]);
|
||||
flags
|
||||
|
|
|
|||
|
|
@ -254,7 +254,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
|
|||
output_ty: Ty<'tcx>)
|
||||
-> Ty<'tcx>
|
||||
{
|
||||
let input_args = input_tys.iter().map(|ty| *ty).collect();
|
||||
let input_args = input_tys.iter().cloned().collect();
|
||||
ty::mk_bare_fn(self.infcx.tcx,
|
||||
None,
|
||||
self.infcx.tcx.mk_bare_fn(ty::BareFnTy {
|
||||
|
|
|
|||
|
|
@ -1920,18 +1920,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
|
|||
-> ResolveResult<(Rc<Module>, LastPrivate)> {
|
||||
fn search_parent_externals(needle: Name, module: &Rc<Module>)
|
||||
-> Option<Rc<Module>> {
|
||||
module.external_module_children.borrow()
|
||||
.get(&needle).cloned()
|
||||
.map(|_| module.clone())
|
||||
.or_else(|| {
|
||||
match module.parent_link.clone() {
|
||||
ModuleParentLink(parent, _) => {
|
||||
search_parent_externals(needle,
|
||||
&parent.upgrade().unwrap())
|
||||
match module.external_module_children.borrow().get(&needle) {
|
||||
Some(_) => Some(module.clone()),
|
||||
None => match module.parent_link {
|
||||
ModuleParentLink(ref parent, _) => {
|
||||
search_parent_externals(needle, &parent.upgrade().unwrap())
|
||||
}
|
||||
_ => None
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
let mut search_module = module_;
|
||||
|
|
|
|||
|
|
@ -3211,7 +3211,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>)
|
|||
reachable.push("rust_eh_personality_catch".to_string());
|
||||
|
||||
if codegen_units > 1 {
|
||||
internalize_symbols(&shared_ccx, &reachable.iter().map(|x| x.clone()).collect());
|
||||
internalize_symbols(&shared_ccx, &reachable.iter().cloned().collect());
|
||||
}
|
||||
|
||||
let metadata_module = ModuleTranslation {
|
||||
|
|
|
|||
|
|
@ -208,7 +208,7 @@ pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>,
|
|||
let function_type = typer.closure_type(closure_id, param_substs);
|
||||
|
||||
let freevars: Vec<ty::Freevar> =
|
||||
ty::with_freevars(tcx, id, |fv| fv.iter().map(|&fv| fv).collect());
|
||||
ty::with_freevars(tcx, id, |fv| fv.iter().cloned().collect());
|
||||
|
||||
let sig = ty::erase_late_bound_regions(tcx, &function_type.sig);
|
||||
|
||||
|
|
|
|||
|
|
@ -1197,7 +1197,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
let trait_ref =
|
||||
bcx.tcx().object_cast_map.borrow()
|
||||
.get(&expr.id)
|
||||
.map(|t| (*t).clone())
|
||||
.cloned()
|
||||
.unwrap();
|
||||
let trait_ref = bcx.monomorphize(&trait_ref);
|
||||
let datum = unpack_datum!(bcx, trans(bcx, &**val));
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ pub fn untuple_arguments_if_necessary<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
|
|||
abi: abi::Abi)
|
||||
-> Vec<Ty<'tcx>> {
|
||||
if abi != abi::RustCall {
|
||||
return inputs.iter().map(|x| (*x).clone()).collect()
|
||||
return inputs.iter().cloned().collect()
|
||||
}
|
||||
|
||||
if inputs.len() == 0 {
|
||||
|
|
|
|||
|
|
@ -640,7 +640,7 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>,
|
|||
// Remember return type so that regionck can access it later.
|
||||
let mut fn_sig_tys: Vec<Ty> =
|
||||
arg_tys.iter()
|
||||
.map(|&ty| ty)
|
||||
.cloned()
|
||||
.collect();
|
||||
|
||||
if let ty::FnConverging(ret_ty) = ret_ty {
|
||||
|
|
@ -3220,7 +3220,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
|
|||
for field in ast_fields {
|
||||
let mut expected_field_type = tcx.types.err;
|
||||
|
||||
let pair = class_field_map.get(&field.ident.node.name).map(|x| *x);
|
||||
let pair = class_field_map.get(&field.ident.node.name).cloned();
|
||||
match pair {
|
||||
None => {
|
||||
fcx.type_error_message(
|
||||
|
|
@ -3852,7 +3852,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
|
|||
}
|
||||
ast::ExprStruct(ref path, ref fields, ref base_expr) => {
|
||||
// Resolve the path.
|
||||
let def = tcx.def_map.borrow().get(&id).map(|i| *i);
|
||||
let def = tcx.def_map.borrow().get(&id).cloned();
|
||||
let struct_id = match def {
|
||||
Some(def::DefVariant(enum_id, variant_id, true)) => {
|
||||
check_struct_enum_variant(fcx, id, expr.span, enum_id,
|
||||
|
|
|
|||
|
|
@ -293,7 +293,7 @@ pub fn collapse_docs(krate: clean::Crate) -> plugins::PluginResult {
|
|||
let mut a: Vec<clean::Attribute> = i.attrs.iter().filter(|&a| match a {
|
||||
&clean::NameValue(ref x, _) if "doc" == *x => false,
|
||||
_ => true
|
||||
}).map(|x| x.clone()).collect();
|
||||
}).cloned().collect();
|
||||
if docstr.len() > 0 {
|
||||
a.push(clean::NameValue("doc".to_string(), docstr));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -333,7 +333,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
name: name,
|
||||
items: items.clone(),
|
||||
generics: gen.clone(),
|
||||
bounds: b.iter().map(|x| (*x).clone()).collect(),
|
||||
bounds: b.iter().cloned().collect(),
|
||||
id: item.id,
|
||||
attrs: item.attrs.clone(),
|
||||
whence: item.span,
|
||||
|
|
|
|||
|
|
@ -926,7 +926,7 @@ mod tests {
|
|||
#[cfg(unix)]
|
||||
fn join_paths_unix() {
|
||||
fn test_eq(input: &[&str], output: &str) -> bool {
|
||||
&*join_paths(input.iter().map(|s| *s)).unwrap() ==
|
||||
&*join_paths(input.iter().cloned()).unwrap() ==
|
||||
OsStr::from_str(output)
|
||||
}
|
||||
|
||||
|
|
@ -935,14 +935,14 @@ mod tests {
|
|||
"/bin:/usr/bin:/usr/local/bin"));
|
||||
assert!(test_eq(&["", "/bin", "", "", "/usr/bin", ""],
|
||||
":/bin:::/usr/bin:"));
|
||||
assert!(join_paths(["/te:st"].iter().map(|s| *s)).is_err());
|
||||
assert!(join_paths(["/te:st"].iter().cloned()).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(windows)]
|
||||
fn join_paths_windows() {
|
||||
fn test_eq(input: &[&str], output: &str) -> bool {
|
||||
&*join_paths(input.iter().map(|s| *s)).unwrap() ==
|
||||
&*join_paths(input.iter().cloned()).unwrap() ==
|
||||
OsStr::from_str(output)
|
||||
}
|
||||
|
||||
|
|
@ -953,6 +953,6 @@ mod tests {
|
|||
r";c:\windows;;;c:\;"));
|
||||
assert!(test_eq(&[r"c:\te;st", r"c:\"],
|
||||
r#""c:\te;st";c:\"#));
|
||||
assert!(join_paths([r#"c:\te"st"#].iter().map(|s| *s)).is_err());
|
||||
assert!(join_paths([r#"c:\te"st"#].iter().cloned()).is_err());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1172,7 +1172,7 @@ mod tests {
|
|||
let exp: &[&[u8]] = &[$($exp),*];
|
||||
assert_eq!(comps, exp);
|
||||
let comps = path.components().rev().collect::<Vec<&[u8]>>();
|
||||
let exp = exp.iter().rev().map(|&x|x).collect::<Vec<&[u8]>>();
|
||||
let exp = exp.iter().rev().cloned().collect::<Vec<&[u8]>>();
|
||||
assert_eq!(comps, exp)
|
||||
}
|
||||
)
|
||||
|
|
@ -1204,7 +1204,7 @@ mod tests {
|
|||
let exp: &[Option<&str>] = &$exp;
|
||||
assert_eq!(comps, exp);
|
||||
let comps = path.str_components().rev().collect::<Vec<Option<&str>>>();
|
||||
let exp = exp.iter().rev().map(|&x|x).collect::<Vec<Option<&str>>>();
|
||||
let exp = exp.iter().rev().cloned().collect::<Vec<Option<&str>>>();
|
||||
assert_eq!(comps, exp);
|
||||
}
|
||||
)
|
||||
|
|
|
|||
|
|
@ -2226,7 +2226,7 @@ mod tests {
|
|||
assert_eq!(comps, exp);
|
||||
let comps = path.str_components().rev().map(|x|x.unwrap())
|
||||
.collect::<Vec<&str>>();
|
||||
let exp = exp.iter().rev().map(|&x|x).collect::<Vec<&str>>();
|
||||
let exp = exp.iter().rev().cloned().collect::<Vec<&str>>();
|
||||
assert_eq!(comps, exp);
|
||||
}
|
||||
);
|
||||
|
|
@ -2282,7 +2282,7 @@ mod tests {
|
|||
let exp: &[&[u8]] = &$exp;
|
||||
assert_eq!(comps, exp);
|
||||
let comps = path.components().rev().collect::<Vec<&[u8]>>();
|
||||
let exp = exp.iter().rev().map(|&x|x).collect::<Vec<&[u8]>>();
|
||||
let exp = exp.iter().rev().cloned().collect::<Vec<&[u8]>>();
|
||||
assert_eq!(comps, exp);
|
||||
}
|
||||
)
|
||||
|
|
|
|||
|
|
@ -547,7 +547,7 @@ mod test {
|
|||
#[test]
|
||||
fn test_choose() {
|
||||
let mut r = thread_rng();
|
||||
assert_eq!(r.choose(&[1, 1, 1]).map(|&x|x), Some(1));
|
||||
assert_eq!(r.choose(&[1, 1, 1]).cloned(), Some(1));
|
||||
|
||||
let v: &[int] = &[];
|
||||
assert_eq!(r.choose(v), None);
|
||||
|
|
|
|||
|
|
@ -251,7 +251,7 @@ impl<'ast> Map<'ast> {
|
|||
}
|
||||
|
||||
fn find_entry(&self, id: NodeId) -> Option<MapEntry<'ast>> {
|
||||
self.map.borrow().get(id as usize).map(|e| *e)
|
||||
self.map.borrow().get(id as usize).cloned()
|
||||
}
|
||||
|
||||
pub fn krate(&self) -> &'ast Crate {
|
||||
|
|
|
|||
|
|
@ -17,10 +17,10 @@ pub struct Registry {
|
|||
|
||||
impl Registry {
|
||||
pub fn new(descriptions: &[(&'static str, &'static str)]) -> Registry {
|
||||
Registry { descriptions: descriptions.iter().map(|&tuple| tuple).collect() }
|
||||
Registry { descriptions: descriptions.iter().cloned().collect() }
|
||||
}
|
||||
|
||||
pub fn find_description(&self, code: &str) -> Option<&'static str> {
|
||||
self.descriptions.get(code).map(|desc| *desc)
|
||||
self.descriptions.get(code).cloned()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -640,7 +640,7 @@ impl<'a> ExtCtxt<'a> {
|
|||
pub fn mod_path(&self) -> Vec<ast::Ident> {
|
||||
let mut v = Vec::new();
|
||||
v.push(token::str_to_ident(&self.ecfg.crate_name[]));
|
||||
v.extend(self.mod_path.iter().map(|a| *a));
|
||||
v.extend(self.mod_path.iter().cloned());
|
||||
return v;
|
||||
}
|
||||
pub fn bt_push(&mut self, ei: ExpnInfo) {
|
||||
|
|
|
|||
|
|
@ -367,7 +367,7 @@ impl<'a> TraitDef<'a> {
|
|||
"allow" | "warn" | "deny" | "forbid" => true,
|
||||
_ => false,
|
||||
}
|
||||
}).map(|a| a.clone()));
|
||||
}).cloned());
|
||||
push(P(ast::Item {
|
||||
attrs: attrs,
|
||||
..(*newitem).clone()
|
||||
|
|
@ -410,7 +410,7 @@ impl<'a> TraitDef<'a> {
|
|||
let mut ty_params = ty_params.into_vec();
|
||||
|
||||
// Copy the lifetimes
|
||||
lifetimes.extend(generics.lifetimes.iter().map(|l| (*l).clone()));
|
||||
lifetimes.extend(generics.lifetimes.iter().cloned());
|
||||
|
||||
// Create the type parameters.
|
||||
ty_params.extend(generics.ty_params.iter().map(|ty_param| {
|
||||
|
|
@ -445,14 +445,14 @@ impl<'a> TraitDef<'a> {
|
|||
span: self.span,
|
||||
bound_lifetimes: wb.bound_lifetimes.clone(),
|
||||
bounded_ty: wb.bounded_ty.clone(),
|
||||
bounds: OwnedSlice::from_vec(wb.bounds.iter().map(|b| b.clone()).collect())
|
||||
bounds: OwnedSlice::from_vec(wb.bounds.iter().cloned().collect())
|
||||
})
|
||||
}
|
||||
ast::WherePredicate::RegionPredicate(ref rb) => {
|
||||
ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate {
|
||||
span: self.span,
|
||||
lifetime: rb.lifetime,
|
||||
bounds: rb.bounds.iter().map(|b| b.clone()).collect()
|
||||
bounds: rb.bounds.iter().cloned().collect()
|
||||
})
|
||||
}
|
||||
ast::WherePredicate::EqPredicate(ref we) => {
|
||||
|
|
@ -500,7 +500,7 @@ impl<'a> TraitDef<'a> {
|
|||
let opt_trait_ref = Some(trait_ref);
|
||||
let ident = ast_util::impl_pretty_name(&opt_trait_ref, &*self_type);
|
||||
let mut a = vec![attr];
|
||||
a.extend(self.attributes.iter().map(|a| a.clone()));
|
||||
a.extend(self.attributes.iter().cloned());
|
||||
cx.item(
|
||||
self.span,
|
||||
ident,
|
||||
|
|
|
|||
|
|
@ -179,7 +179,7 @@ pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
|
|||
return DummyResult::expr(sp);
|
||||
}
|
||||
Ok(bytes) => {
|
||||
let bytes = bytes.iter().map(|x| *x).collect();
|
||||
let bytes = bytes.iter().cloned().collect();
|
||||
base::MacExpr::new(cx.expr_lit(sp, ast::LitBinary(Rc::new(bytes))))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -283,7 +283,7 @@ pub fn parse(sess: &ParseSess,
|
|||
-> ParseResult {
|
||||
let mut cur_eis = Vec::new();
|
||||
cur_eis.push(initial_matcher_pos(Rc::new(ms.iter()
|
||||
.map(|x| (*x).clone())
|
||||
.cloned()
|
||||
.collect()),
|
||||
None,
|
||||
rdr.peek().sp.lo));
|
||||
|
|
|
|||
|
|
@ -159,7 +159,7 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt,
|
|||
None,
|
||||
None,
|
||||
arg.iter()
|
||||
.map(|x| (*x).clone())
|
||||
.cloned()
|
||||
.collect(),
|
||||
true);
|
||||
match parse(cx.parse_sess(), cx.cfg(), arg_rdr, lhs_tt) {
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ pub fn doc_comment_style(comment: &str) -> ast::AttrStyle {
|
|||
|
||||
pub fn strip_doc_comment_decoration(comment: &str) -> String {
|
||||
/// remove whitespace-only lines from the start/end of lines
|
||||
fn vertical_trim(lines: Vec<String> ) -> Vec<String> {
|
||||
fn vertical_trim(lines: Vec<String>) -> Vec<String> {
|
||||
let mut i = 0;
|
||||
let mut j = lines.len();
|
||||
// first line of all-stars should be omitted
|
||||
|
|
@ -82,7 +82,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String {
|
|||
while j > i && lines[j - 1].trim().is_empty() {
|
||||
j -= 1;
|
||||
}
|
||||
return lines[i..j].iter().map(|x| (*x).clone()).collect();
|
||||
lines[i..j].iter().cloned().collect()
|
||||
}
|
||||
|
||||
/// remove a "[ \t]*\*" block from each line, if possible
|
||||
|
|
|
|||
|
|
@ -240,9 +240,8 @@ macro_rules! maybe_whole {
|
|||
|
||||
fn maybe_append(mut lhs: Vec<Attribute>, rhs: Option<Vec<Attribute>>)
|
||||
-> Vec<Attribute> {
|
||||
match rhs {
|
||||
Some(ref attrs) => lhs.extend(attrs.iter().map(|a| a.clone())),
|
||||
None => {}
|
||||
if let Some(ref attrs) = rhs {
|
||||
lhs.extend(attrs.iter().cloned())
|
||||
}
|
||||
lhs
|
||||
}
|
||||
|
|
@ -467,7 +466,7 @@ impl<'a> Parser<'a> {
|
|||
debug!("commit_expr {:?}", e);
|
||||
if let ExprPath(..) = e.node {
|
||||
// might be unit-struct construction; check for recoverableinput error.
|
||||
let mut expected = edible.iter().map(|x| x.clone()).collect::<Vec<_>>();
|
||||
let mut expected = edible.iter().cloned().collect::<Vec<_>>();
|
||||
expected.push_all(inedible);
|
||||
self.check_for_erroneous_unit_struct_expecting(&expected[]);
|
||||
}
|
||||
|
|
@ -485,7 +484,7 @@ impl<'a> Parser<'a> {
|
|||
if self.last_token
|
||||
.as_ref()
|
||||
.map_or(false, |t| t.is_ident() || t.is_path()) {
|
||||
let mut expected = edible.iter().map(|x| x.clone()).collect::<Vec<_>>();
|
||||
let mut expected = edible.iter().cloned().collect::<Vec<_>>();
|
||||
expected.push_all(&inedible[]);
|
||||
self.check_for_erroneous_unit_struct_expecting(
|
||||
&expected[]);
|
||||
|
|
@ -1706,7 +1705,7 @@ impl<'a> Parser<'a> {
|
|||
(true, LitBinary(parse::binary_lit(i.as_str()))),
|
||||
token::BinaryRaw(i, _) =>
|
||||
(true,
|
||||
LitBinary(Rc::new(i.as_str().as_bytes().iter().map(|&x| x).collect()))),
|
||||
LitBinary(Rc::new(i.as_str().as_bytes().iter().cloned().collect()))),
|
||||
};
|
||||
|
||||
if suffix_illegal {
|
||||
|
|
|
|||
|
|
@ -983,15 +983,14 @@ impl<'a> State<'a> {
|
|||
try!(self.word_nbsp("trait"));
|
||||
try!(self.print_ident(item.ident));
|
||||
try!(self.print_generics(generics));
|
||||
let bounds: Vec<_> = bounds.iter().map(|b| b.clone()).collect();
|
||||
let mut real_bounds = Vec::with_capacity(bounds.len());
|
||||
for b in bounds {
|
||||
if let TraitTyParamBound(ref ptr, ast::TraitBoundModifier::Maybe) = b {
|
||||
for b in bounds.iter() {
|
||||
if let TraitTyParamBound(ref ptr, ast::TraitBoundModifier::Maybe) = *b {
|
||||
try!(space(&mut self.s));
|
||||
try!(self.word_space("for ?"));
|
||||
try!(self.print_trait_ref(&ptr.trait_ref));
|
||||
} else {
|
||||
real_bounds.push(b);
|
||||
real_bounds.push(b.clone());
|
||||
}
|
||||
}
|
||||
try!(self.print_bounds(":", &real_bounds[]));
|
||||
|
|
|
|||
|
|
@ -608,7 +608,7 @@ mod test {
|
|||
Result<Vec<u8>, String>
|
||||
{
|
||||
let mut u8v: Vec<_> = fmt.bytes().collect();
|
||||
u8v.extend(cap.as_bytes().iter().map(|&b| b));
|
||||
u8v.extend(cap.bytes());
|
||||
expand(&u8v, params, vars)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -132,7 +132,7 @@ fn run<W: Writer>(writer: &mut W) -> std::old_io::IoResult<()> {
|
|||
('t', 0.3015094502008)];
|
||||
|
||||
try!(make_fasta(writer, ">ONE Homo sapiens alu\n",
|
||||
alu.as_bytes().iter().cycle().map(|c| *c), n * 2));
|
||||
alu.as_bytes().iter().cycle().cloned(), n * 2));
|
||||
try!(make_fasta(writer, ">TWO IUB ambiguity codes\n",
|
||||
AAGen::new(rng, iub), n * 3));
|
||||
try!(make_fasta(writer, ">THREE Homo sapiens frequency\n",
|
||||
|
|
|
|||
|
|
@ -202,7 +202,7 @@ fn filter_masks(masks: &mut Vec<Vec<Vec<u64>>>) {
|
|||
for i in 0..masks.len() {
|
||||
for j in 0..(*masks)[i].len() {
|
||||
masks[i][j] =
|
||||
(*masks)[i][j].iter().map(|&m| m)
|
||||
(*masks)[i][j].iter().cloned()
|
||||
.filter(|&m| !is_board_unfeasible(m, masks))
|
||||
.collect();
|
||||
}
|
||||
|
|
@ -270,7 +270,7 @@ fn handle_sol(raw_sol: &List<u64>, data: &mut Data) {
|
|||
// reverse order, i.e. the board rotated by half a turn.
|
||||
data.nb += 2;
|
||||
let sol1 = to_vec(raw_sol);
|
||||
let sol2: Vec<u8> = sol1.iter().rev().map(|x| *x).collect();
|
||||
let sol2: Vec<u8> = sol1.iter().rev().cloned().collect();
|
||||
|
||||
if data.nb == 2 {
|
||||
data.min = sol1.clone();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue