s/([^\(\s]+\.)len\(\) != 0/!$1is_empty()/g

Author: tamird

src/libfmt_macros/lib.rs

@@ -463,7 +463,7 @@ mod tests {
     fn musterr(s: &str) {
         let mut p = Parser::new(s);
         p.next();
-        assert!(p.errors.len() != 0);
+        assert!(!p.errors.is_empty());
     }
 
     #[test]

src/librustc/middle/infer/combine.rs

@@ -589,7 +589,7 @@ pub fn super_tys<'tcx, C>(this: &C,
                    .map(|(a, b)| this.tys(*a, *b))
                    .collect::<Result<_, _>>()
                    .map(|ts| ty::mk_tup(tcx, ts))
-            } else if as_.len() != 0 && bs.len() != 0 {
+            } else if !as_.is_empty() && !bs.is_empty() {
                 Err(ty::terr_tuple_size(
                     expected_found(this, as_.len(), bs.len())))
             } else {

src/librustc/middle/ty.rs

@@ -3698,7 +3698,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
                     res = res | TC::OwnsDtor;
                 }
 
-                if variants.len() != 0 {
+                if !variants.is_empty() {
                     let repr_hints = lookup_repr_hints(cx, did);
                     if repr_hints.len() > 1 {
                         // this is an error later on, but this type isn't safe

src/librustc_trans/trans/base.rs

@@ -2797,7 +2797,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
                     ccx.sess().bug("struct variant kind unexpected in get_item_val")
                 }
             };
-            assert!(args.len() != 0);
+            assert!(!args.is_empty());
             let ty = ty::node_id_to_type(ccx.tcx(), id);
             let parent = ccx.tcx().map.get_parent(id);
             let enm = ccx.tcx().map.expect_item(parent);

src/librustc_typeck/astconv.rs

@@ -1850,7 +1850,7 @@ fn compute_object_lifetime_bound<'tcx>(
             "only a single explicit lifetime bound is permitted");
     }
 
-    if explicit_region_bounds.len() != 0 {
+    if !explicit_region_bounds.is_empty() {
         // Explicitly specified region bound. Use that.
         let r = explicit_region_bounds[0];
         return ast_region_to_region(tcx, r);

src/libstd/old_io/util.rs

@@ -313,7 +313,7 @@ impl<T: Iterator<Item=u8>> Reader for IterReader<T> {
             *slot = elt;
             len += 1;
         }
-        if len == 0 && buf.len() != 0 {
+        if len == 0 && !buf.is_empty() {
             Err(old_io::standard_error(old_io::EndOfFile))
         } else {
             Ok(len)

src/libsyntax/ext/asm.rs

@@ -90,7 +90,7 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                       p.token != token::Colon &&
                       p.token != token::ModSep {
 
-                    if outputs.len() != 0 {
+                    if !outputs.is_empty() {
                         p.eat(&token::Comma);
                     }
 
@@ -130,7 +130,7 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                       p.token != token::Colon &&
                       p.token != token::ModSep {
 
-                    if inputs.len() != 0 {
+                    if !inputs.is_empty() {
                         p.eat(&token::Comma);
                     }
 
@@ -154,7 +154,7 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                       p.token != token::Colon &&
                       p.token != token::ModSep {
 
-                    if clobs.len() != 0 {
+                    if !clobs.is_empty() {
                         p.eat(&token::Comma);
                     }
 

src/libsyntax/ext/base.rs

@@ -782,7 +782,7 @@ pub fn check_zero_tts(cx: &ExtCtxt,
                       sp: Span,
                       tts: &[ast::TokenTree],
                       name: &str) {
-    if tts.len() != 0 {
+    if !tts.is_empty() {
         cx.span_err(sp, &format!("{} takes no arguments", name));
     }
 }

src/libsyntax/parse/lexer/comments.rs

@@ -294,7 +294,7 @@ fn read_block_comment(rdr: &mut StringReader,
                 }
             }
         }
-        if curr_line.len() != 0 {
+        if !curr_line.is_empty() {
             trim_whitespace_prefix_and_push_line(&mut lines,
                                                  curr_line,
                                                  col);

src/libsyntax/parse/parser.rs

@@ -3005,7 +3005,7 @@ impl<'a> Parser<'a> {
                 self.expect(&token::Comma);
 
                 if self.token == token::CloseDelim(token::Bracket)
-                        && (before_slice || after.len() != 0) {
+                        && (before_slice || !after.is_empty()) {
                     break
                 }
             }

src/libsyntax/print/pp.rs

@@ -565,7 +565,7 @@ impl<'a> Printer<'a> {
           Token::End => {
             debug!("print End -> pop End");
             let print_stack = &mut self.print_stack;
-            assert!((print_stack.len() != 0));
+            assert!((!print_stack.is_empty()));
             print_stack.pop().unwrap();
             Ok(())
           }

src/libsyntax/print/pprust.rs

@@ -2205,7 +2205,7 @@ impl<'a> State<'a> {
                     },
                     |f| f.node.pat.span));
                 if etc {
-                    if fields.len() != 0 { try!(self.word_space(",")); }
+                    if !fields.is_empty() { try!(self.word_space(",")); }
                     try!(word(&mut self.s, ".."));
                 }
                 try!(space(&mut self.s));

src/libtest/stats.rs

@@ -196,17 +196,17 @@ impl<T: Float + FromPrimitive> Stats<T> for [T] {
     }
 
     fn min(&self) -> T {
-        assert!(self.len() != 0);
+        assert!(!self.is_empty());
         self.iter().fold(self[0], |p, q| p.min(*q))
     }
 
     fn max(&self) -> T {
-        assert!(self.len() != 0);
+        assert!(!self.is_empty());
         self.iter().fold(self[0], |p, q| p.max(*q))
     }
 
     fn mean(&self) -> T {
-        assert!(self.len() != 0);
+        assert!(!self.is_empty());
         self.sum() / FromPrimitive::from_usize(self.len()).unwrap()
     }
 
@@ -284,7 +284,7 @@ impl<T: Float + FromPrimitive> Stats<T> for [T] {
 // linear interpolation. If samples are not sorted, return nonsensical value.
 fn percentile_of_sorted<T: Float + FromPrimitive>(sorted_samples: &[T],
                                                              pct: T) -> T {
-    assert!(sorted_samples.len() != 0);
+    assert!(!sorted_samples.is_empty());
     if sorted_samples.len() == 1 {
         return sorted_samples[0];
     }

src/test/bench/shootout-k-nucleotide.rs

@@ -252,7 +252,7 @@ fn generate_frequencies(mut input: &[u8], frame: usize) -> Table {
     }
     frequencies.lookup(code, BumpCallback);
 
-    while input.len() != 0 && input[0] != ('>' as u8) {
+    while !input.is_empty() && input[0] != ('>' as u8) {
         code = code.rotate(input[0], frame);
         frequencies.lookup(code, BumpCallback);
         input = &input[1..];