Obsolete the closure kind syntax

src/compiletest/compiletest.rs

@@ -359,7 +359,7 @@ pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::Test
  let config = (*config).clone();
  // FIXME (#9639): This needs to handle non-utf8 paths
  let testfile = testfile.as_str().unwrap().to_string();
- test::DynMetricFn(box move |: mm: &mut test::MetricMap| {
+ test::DynMetricFn(box move |mm: &mut test::MetricMap| {
  runtest::run_metrics(config, testfile, mm)
  })
 }

src/libcollections/str.rs

@@ -199,7 +199,7 @@ impl<'a> Iterator for Decompositions<'a> {
  let buffer = &mut self.buffer;
  let sorted = &mut self.sorted;
  {
- let callback = |&mut: d| {
+ let callback = |d| {
  let class =
  unicode::char::canonical_combining_class(d);
  if class == 0 && !*sorted {
@@ -592,7 +592,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
  /// let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
  /// assert_eq!(v, vec!["Mary", "had", "a", "little", "lamb"]);
  ///
- /// let v: Vec<&str> = "abc1def2ghi".split(|&: c: char| c.is_numeric()).collect();
+ /// let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect();
  /// assert_eq!(v, vec!["abc", "def", "ghi"]);
  ///
  /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
@@ -616,7 +616,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
  /// let v: Vec<&str> = "Mary had a little lambda".splitn(2, ' ').collect();
  /// assert_eq!(v, vec!["Mary", "had", "a little lambda"]);
  ///
- /// let v: Vec<&str> = "abc1def2ghi".splitn(1, |&: c: char| c.is_numeric()).collect();
+ /// let v: Vec<&str> = "abc1def2ghi".splitn(1, |c: char| c.is_numeric()).collect();
  /// assert_eq!(v, vec!["abc", "def2ghi"]);
  ///
  /// let v: Vec<&str> = "lionXXtigerXleopard".splitn(2, 'X').collect();
@@ -651,7 +651,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
  /// let v: Vec<&str> = "Mary had a little lamb".split(' ').rev().collect();
  /// assert_eq!(v, vec!["lamb", "little", "a", "had", "Mary"]);
  ///
- /// let v: Vec<&str> = "abc1def2ghi".split(|&: c: char| c.is_numeric()).rev().collect();
+ /// let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).rev().collect();
  /// assert_eq!(v, vec!["ghi", "def", "abc"]);
  ///
  /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').rev().collect();
@@ -672,7 +672,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
  /// let v: Vec<&str> = "Mary had a little lamb".rsplitn(2, ' ').collect();
  /// assert_eq!(v, vec!["lamb", "little", "Mary had a"]);
  ///
- /// let v: Vec<&str> = "abc1def2ghi".rsplitn(1, |&: c: char| c.is_numeric()).collect();
+ /// let v: Vec<&str> = "abc1def2ghi".rsplitn(1, |c: char| c.is_numeric()).collect();
  /// assert_eq!(v, vec!["ghi", "abc1def"]);
  ///
  /// let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(2, 'X').collect();
@@ -853,7 +853,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
  /// assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
  /// let x: &[_] = &['1', '2'];
  /// assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");
- /// assert_eq!("123foo1bar123".trim_matches(|&: c: char| c.is_numeric()), "foo1bar");
+ /// assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar");
  /// ```
  #[stable(feature = "rust1", since = "1.0.0")]
  fn trim_matches<P: CharEq>(&self, pat: P) -> &str {
@@ -873,7 +873,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
  /// assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
  /// let x: &[_] = &['1', '2'];
  /// assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");
- /// assert_eq!("123foo1bar123".trim_left_matches(|&: c: char| c.is_numeric()), "foo1bar123");
+ /// assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123");
  /// ```
  #[stable(feature = "rust1", since = "1.0.0")]
  fn trim_left_matches<P: CharEq>(&self, pat: P) -> &str {
@@ -893,7 +893,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
  /// assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
  /// let x: &[_] = &['1', '2'];
  /// assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");
- /// assert_eq!("123foo1bar123".trim_right_matches(|&: c: char| c.is_numeric()), "123foo1bar");
+ /// assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar");
  /// ```
  #[stable(feature = "rust1", since = "1.0.0")]
  fn trim_right_matches<P: CharEq>(&self, pat: P) -> &str {
@@ -1066,7 +1066,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
  /// assert_eq!(s.find('é'), Some(14));
  ///
  /// // the first space
- /// assert_eq!(s.find(|&: c: char| c.is_whitespace()), Some(5));
+ /// assert_eq!(s.find(|c: char| c.is_whitespace()), Some(5));
  ///
  /// // neither are found
  /// let x: &[_] = &['1', '2'];
@@ -1094,7 +1094,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
  /// assert_eq!(s.rfind('é'), Some(14));
  ///
  /// // the second space
- /// assert_eq!(s.rfind(|&: c: char| c.is_whitespace()), Some(12));
+ /// assert_eq!(s.rfind(|c: char| c.is_whitespace()), Some(12));
  ///
  /// // searches for an occurrence of either `1` or `2`, but neither are found
  /// let x: &[_] = &['1', '2'];
@@ -1387,21 +1387,21 @@ mod tests {
  #[test]
  fn test_find() {
  assert_eq!("hello".find('l'), Some(2u));
- assert_eq!("hello".find(|&: c:char| c == 'o'), Some(4u));
+ assert_eq!("hello".find(|c:char| c == 'o'), Some(4u));
  assert!("hello".find('x').is_none());
- assert!("hello".find(|&: c:char| c == 'x').is_none());
+ assert!("hello".find(|c:char| c == 'x').is_none());
  assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30u));
- assert_eq!("ประเทศไทย中华Việt Nam".find(|&: c: char| c == '华'), Some(30u));
+ assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30u));
  }
 
  #[test]
  fn test_rfind() {
  assert_eq!("hello".rfind('l'), Some(3u));
- assert_eq!("hello".rfind(|&: c:char| c == 'o'), Some(4u));
+ assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4u));
  assert!("hello".rfind('x').is_none());
- assert!("hello".rfind(|&: c:char| c == 'x').is_none());
+ assert!("hello".rfind(|c:char| c == 'x').is_none());
  assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30u));
- assert_eq!("ประเทศไทย中华Việt Nam".rfind(|&: c: char| c == '华'), Some(30u));
+ assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30u));
  }
 
  #[test]
@@ -1723,7 +1723,7 @@ mod tests {
  assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
  let chars: &[char] = &['1', '2'];
  assert_eq!("12foo1bar12".trim_left_matches(chars), "foo1bar12");
- assert_eq!("123foo1bar123".trim_left_matches(|&: c: char| c.is_numeric()), "foo1bar123");
+ assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123");
  }
 
  #[test]
@@ -1738,7 +1738,7 @@ mod tests {
  assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
  let chars: &[char] = &['1', '2'];
  assert_eq!("12foo1bar12".trim_right_matches(chars), "12foo1bar");
- assert_eq!("123foo1bar123".trim_right_matches(|&: c: char| c.is_numeric()), "123foo1bar");
+ assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar");
  }
 
  #[test]
@@ -1753,7 +1753,7 @@ mod tests {
  assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
  let chars: &[char] = &['1', '2'];
  assert_eq!("12foo1bar12".trim_matches(chars), "foo1bar");
- assert_eq!("123foo1bar123".trim_matches(|&: c: char| c.is_numeric()), "foo1bar");
+ assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar");
  }
 
  #[test]
@@ -2222,14 +2222,14 @@ mod tests {
  let split: Vec<&str> = data.splitn(3, ' ').collect();
  assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
 
- let split: Vec<&str> = data.splitn(3, |&: c: char| c == ' ').collect();
+ let split: Vec<&str> = data.splitn(3, |c: char| c == ' ').collect();
  assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
 
  // Unicode
  let split: Vec<&str> = data.splitn(3, 'ä').collect();
  assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
 
- let split: Vec<&str> = data.splitn(3, |&: c: char| c == 'ä').collect();
+ let split: Vec<&str> = data.splitn(3, |c: char| c == 'ä').collect();
  assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
  }
 
@@ -2940,7 +2940,7 @@ mod bench {
  let s = "Mary had a little lamb, Little lamb, little-lamb.";
  let len = s.split(' ').count();
 
- b.iter(|| assert_eq!(s.split(|&: c: char| c == ' ').count(), len));
+ b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
  }
 
  #[bench]

src/libcore/finally.rs

@@ -23,7 +23,7 @@
 //!
 //! use std::finally::Finally;
 //!
-//! (|&mut:| {
+//! (|| {
 //! // ...
 //! }).finally(|| {
 //! // this code is always run

src/libcore/fmt/float.rs

@@ -225,10 +225,10 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
  // cut off the one extra digit, and depending on its value
  // round the remaining ones.
  if limit_digits && dig == digit_count {
- let ascii2value = |&: chr: u8| {
+ let ascii2value = |chr: u8| {
  (chr as char).to_digit(radix).unwrap()
  };
- let value2ascii = |&: val: uint| {
+ let value2ascii = |val: uint| {
  char::from_digit(val, radix).unwrap() as u8
  };
 

src/libcore/fmt/mod.rs

@@ -483,7 +483,7 @@ impl<'a> Formatter<'a> {
  }
 
  // Writes the sign if it exists, and then the prefix if it was requested
- let write_prefix = |&: f: &mut Formatter| {
+ let write_prefix = |f: &mut Formatter| {
  if let Some(c) = sign {
  let mut b = [0; 4];
  let n = c.encode_utf8(&mut b).unwrap_or(0);

src/libcore/str/mod.rs

@@ -1518,11 +1518,11 @@ impl StrExt for str {
 
  #[inline]
  fn trim_matches<P: CharEq>(&self, mut pat: P) -> &str {
- let cur = match self.find(|&mut: c: char| !pat.matches(c)) {
+ let cur = match self.find(|c: char| !pat.matches(c)) {
  None => "",
  Some(i) => unsafe { self.slice_unchecked(i, self.len()) }
  };
- match cur.rfind(|&mut: c: char| !pat.matches(c)) {
+ match cur.rfind(|c: char| !pat.matches(c)) {
  None => "",
  Some(i) => {
  let right = cur.char_range_at(i).next;
@@ -1533,15 +1533,15 @@ impl StrExt for str {
 
  #[inline]
  fn trim_left_matches<P: CharEq>(&self, mut pat: P) -> &str {
- match self.find(|&mut: c: char| !pat.matches(c)) {
+ match self.find(|c: char| !pat.matches(c)) {
  None => "",
  Some(first) => unsafe { self.slice_unchecked(first, self.len()) }
  }
  }
 
  #[inline]
  fn trim_right_matches<P: CharEq>(&self, mut pat: P) -> &str {
- match self.rfind(|&mut: c: char| !pat.matches(c)) {
+ match self.rfind(|c: char| !pat.matches(c)) {
  None => "",
  Some(last) => {
  let next = self.char_range_at(last).next;

src/libcoretest/finally.rs

@@ -47,8 +47,9 @@ fn test_fail() {
 
 #[test]
 fn test_retval() {
- let mut closure = |&mut:| 10;
- let i = closure.finally(|| { });
+ let mut closure = || 10;
+ // FIXME(#16640) `: i32` annotation shouldn't be necessary
+ let i: i32 = closure.finally(|| { });
  assert_eq!(i, 10);
 }
 

src/libcoretest/str.rs

@@ -54,7 +54,7 @@ fn test_rsplitn_char_iterator() {
  split.reverse();
  assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);
 
- let mut split: Vec<&str> = data.rsplitn(3, |&: c: char| c == ' ').collect();
+ let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == ' ').collect();
  split.reverse();
  assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);
 
@@ -63,7 +63,7 @@ fn test_rsplitn_char_iterator() {
  split.reverse();
  assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);
 
- let mut split: Vec<&str> = data.rsplitn(3, |&: c: char| c == 'ä').collect();
+ let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == 'ä').collect();
  split.reverse();
  assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);
 }
@@ -79,10 +79,10 @@ fn test_split_char_iterator() {
  rsplit.reverse();
  assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);
 
- let split: Vec<&str> = data.split(|&: c: char| c == ' ').collect();
+ let split: Vec<&str> = data.split(|c: char| c == ' ').collect();
  assert_eq!( split, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);
 
- let mut rsplit: Vec<&str> = data.split(|&: c: char| c == ' ').rev().collect();
+ let mut rsplit: Vec<&str> = data.split(|c: char| c == ' ').rev().collect();
  rsplit.reverse();
  assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);
 
@@ -94,10 +94,10 @@ fn test_split_char_iterator() {
  rsplit.reverse();
  assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
 
- let split: Vec<&str> = data.split(|&: c: char| c == 'ä').collect();
+ let split: Vec<&str> = data.split(|c: char| c == 'ä').collect();
  assert_eq!( split, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
 
- let mut rsplit: Vec<&str> = data.split(|&: c: char| c == 'ä').rev().collect();
+ let mut rsplit: Vec<&str> = data.split(|c: char| c == 'ä').rev().collect();
  rsplit.reverse();
  assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
 }

src/libgetopts/lib.rs

@@ -889,7 +889,7 @@ fn each_split_within<F>(ss: &str, lim: uint, mut it: F) -> bool where
  lim = fake_i;
  }
 
- let mut machine = |&mut: cont: &mut bool, (i, c): (uint, char)| -> bool {
+ let mut machine = |cont: &mut bool, (i, c): (uint, char)| -> bool {
  let whitespace = if c.is_whitespace() { Ws } else { Cr };
  let limit = if (i - slice_start + 1) <= lim { UnderLim } else { OverLim };
 

src/liblog/lib.rs

@@ -428,7 +428,7 @@ fn init() {
  DIRECTIVES = mem::transmute(box directives);
 
  // Schedule the cleanup for the globals for when the runtime exits.
- rt::at_exit(move |:| {
+ rt::at_exit(move || {
  assert!(!DIRECTIVES.is_null());
  let _directives: Box<Vec<directive::LogDirective>> =
  mem::transmute(DIRECTIVES);

src/librustc/lint/builtin.rs

@@ -949,7 +949,7 @@ impl NonSnakeCase {
  fn to_snake_case(mut str: &str) -> String {
  let mut words = vec![];
  // Preserve leading underscores
- str = str.trim_left_matches(|&mut: c: char| {
+ str = str.trim_left_matches(|c: char| {
  if c == '_' {
  words.push(String::new());
  true

src/librustc/metadata/creader.rs

@@ -72,7 +72,7 @@ struct CrateInfo {
 }
 
 pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) {
- let err = |&: s: &str| {
+ let err = |s: &str| {
  match (sp, sess) {
  (_, None) => panic!("{}", s),
  (Some(sp), Some(sess)) => sess.span_err(sp, s),

src/librustc/metadata/csearch.rs

@@ -59,7 +59,7 @@ pub fn each_child_of_item<F>(cstore: &cstore::CStore,
  F: FnMut(decoder::DefLike, ast::Name, ast::Visibility),
 {
  let crate_data = cstore.get_crate_data(def_id.krate);
- let get_crate_data = |&mut: cnum| {
+ let get_crate_data = |cnum| {
  cstore.get_crate_data(cnum)
  };
  decoder::each_child_of_item(cstore.intr.clone(),
@@ -76,7 +76,7 @@ pub fn each_top_level_item_of_crate<F>(cstore: &cstore::CStore,
  F: FnMut(decoder::DefLike, ast::Name, ast::Visibility),
 {
  let crate_data = cstore.get_crate_data(cnum);
- let get_crate_data = |&mut: cnum| {
+ let get_crate_data = |cnum| {
  cstore.get_crate_data(cnum)
  };
  decoder::each_top_level_item_of_crate(cstore.intr.clone(),

src/librustc/metadata/encoder.rs

@@ -1409,7 +1409,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
  encode_parent_sort(rbml_w, 't');
 
  let trait_item = &ms[i];
- let encode_trait_item = |&: rbml_w: &mut Encoder| {
+ let encode_trait_item = |rbml_w: &mut Encoder| {
  // If this is a static method, we've already
  // encoded this.
  if is_nonstatic_method {

src/librustc/middle/check_const.rs

@@ -138,7 +138,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) {
  ast::ExprBlock(ref block) => {
  // Check all statements in the block
  for stmt in &block.stmts {
- let block_span_err = |&: span|
+ let block_span_err = |span|
  span_err!(v.tcx.sess, span, E0016,
  "blocks in constants are limited to items and \
  tail expressions");

src/librustc/middle/check_match.rs

@@ -1024,7 +1024,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
  })
  }
 
- let check_move = |&: p: &Pat, sub: Option<&Pat>| {
+ let check_move = |p: &Pat, sub: Option<&Pat>| {
  // check legality of moving out of the enum
 
  // x @ Foo(..) is legal, but x @ Foo(y) isn't.

src/librustc/middle/infer/region_inference/graphviz.rs

@@ -135,7 +135,7 @@ impl<'a, 'tcx> ConstraintGraph<'a, 'tcx> {
  let mut i = 0;
  let mut node_ids = FnvHashMap();
  {
- let mut add_node = |&mut : node| {
+ let mut add_node = |node| {
  if let Vacant(e) = node_ids.entry(node) {
  e.insert(i);
  i += 1;

src/librustc/middle/region.rs

@@ -666,7 +666,7 @@ fn resolve_expr(visitor: &mut RegionResolutionVisitor, expr: &ast::Expr) {
 
  {
  let region_maps = &mut visitor.region_maps;
- let terminating = |&: id| {
+ let terminating = |id| {
  let scope = CodeExtent::from_node_id(id);
  region_maps.mark_as_terminating_scope(scope)
  };