Negative case of len() -> is_empty()

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

Author: tamird

src/compiletest/compiletest.rs

@@ -368,7 +368,7 @@ pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::Test
 fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
     match full_version_line {
         Some(ref full_version_line)
-          if full_version_line.trim().len() > 0 => {
+          if !full_version_line.trim().is_empty() => {
             let full_version_line = full_version_line.trim();
 
             // used to be a regex "(^|[^0-9])([0-9]\.[0-9])([^0-9]|$)"
@@ -408,7 +408,7 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
 
     match full_version_line {
         Some(ref full_version_line)
-          if full_version_line.trim().len() > 0 => {
+          if !full_version_line.trim().is_empty() => {
             let full_version_line = full_version_line.trim();
 
             for (pos, l) in full_version_line.char_indices() {
@@ -426,7 +426,7 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
                 let vers = full_version_line[pos + 5..].chars().take_while(|c| {
                     c.is_digit(10)
                 }).collect::<String>();
-                if vers.len() > 0 { return Some(vers) }
+                if !vers.is_empty() { return Some(vers) }
             }
             println!("Could not extract LLDB version from line '{}'",
                      full_version_line);

src/libcollections/btree/node.rs

@@ -1225,7 +1225,7 @@ impl<K, V> Node<K, V> {
     /// because we have one too many, and our parent now has one too few
     fn split(&mut self) -> (K, V, Node<K, V>) {
         // Necessary for correctness, but in a private function
-        debug_assert!(self.len() > 0);
+        debug_assert!(!self.is_empty());
 
         let mut right = if self.is_leaf() {
             Node::new_leaf(self.capacity())

src/libfmt_macros/lib.rs

@@ -371,7 +371,7 @@ impl<'a> Parser<'a> {
             None => {
                 let tmp = self.cur.clone();
                 match self.word() {
-                    word if word.len() > 0 => {
+                    word if !word.is_empty() => {
                         if self.consume('$') {
                             CountIsName(word)
                         } else {
@@ -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/libgetopts/lib.rs

@@ -804,7 +804,7 @@ fn format_option(opt: &OptGroup) -> String {
     }
 
     // Use short_name is possible, but fallback to long_name.
-    if opt.short_name.len() > 0 {
+    if !opt.short_name.is_empty() {
         line.push('-');
         line.push_str(&opt.short_name[..]);
     } else {

src/librustc/metadata/encoder.rs

@@ -470,7 +470,7 @@ fn each_auxiliary_node_id<F>(item: &ast::Item, callback: F) -> bool where
         ast::ItemStruct(ref struct_def, _) => {
             // If this is a newtype struct, return the constructor.
             match struct_def.ctor_id {
-                Some(ctor_id) if struct_def.fields.len() > 0 &&
+                Some(ctor_id) if !struct_def.fields.is_empty() &&
                         struct_def.fields[0].node.kind.is_unnamed() => {
                     continue_ = callback(ctor_id);
                 }

src/librustc/metadata/loader.rs

@@ -307,13 +307,13 @@ impl<'a> Context<'a> {
     }
 
     pub fn report_load_errs(&mut self) {
-        let message = if self.rejected_via_hash.len() > 0 {
+        let message = if !self.rejected_via_hash.is_empty() {
             format!("found possibly newer version of crate `{}`",
                     self.ident)
-        } else if self.rejected_via_triple.len() > 0 {
+        } else if !self.rejected_via_triple.is_empty() {
             format!("couldn't find crate `{}` with expected target triple {}",
                     self.ident, self.triple)
-        } else if self.rejected_via_kind.len() > 0 {
+        } else if !self.rejected_via_kind.is_empty() {
             format!("found staticlib `{}` instead of rlib or dylib", self.ident)
         } else {
             format!("can't find crate for `{}`", self.ident)
@@ -325,15 +325,15 @@ impl<'a> Context<'a> {
         };
         self.sess.span_err(self.span, &message[..]);
 
-        if self.rejected_via_triple.len() > 0 {
+        if !self.rejected_via_triple.is_empty() {
             let mismatches = self.rejected_via_triple.iter();
             for (i, &CrateMismatch{ ref path, ref got }) in mismatches.enumerate() {
                 self.sess.fileline_note(self.span,
                     &format!("crate `{}`, path #{}, triple {}: {}",
                             self.ident, i+1, got, path.display()));
             }
         }
-        if self.rejected_via_hash.len() > 0 {
+        if !self.rejected_via_hash.is_empty() {
             self.sess.span_note(self.span, "perhaps this crate needs \
                                             to be recompiled?");
             let mismatches = self.rejected_via_hash.iter();
@@ -353,7 +353,7 @@ impl<'a> Context<'a> {
                 }
             }
         }
-        if self.rejected_via_kind.len() > 0 {
+        if !self.rejected_via_kind.is_empty() {
             self.sess.fileline_help(self.span, "please recompile this crate using \
                                             --crate-type lib");
             let mismatches = self.rejected_via_kind.iter();

src/librustc/middle/dead.rs

@@ -182,7 +182,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
 
     fn mark_live_symbols(&mut self) {
         let mut scanned = HashSet::new();
-        while self.worklist.len() > 0 {
+        while !self.worklist.is_empty() {
             let id = self.worklist.pop().unwrap();
             if scanned.contains(&id) {
                 continue

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/infer/error_reporting.rs

@@ -965,7 +965,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
     fn pick_lifetime(&self,
                      region_names: &HashSet<ast::Name>)
                      -> (ast::Lifetime, FreshOrKept) {
-        if region_names.len() > 0 {
+        if !region_names.is_empty() {
             // It's not necessary to convert the set of region names to a
             // vector of string and then sort them. However, it makes the
             // choice of lifetime name deterministic and thus easier to test.

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

@@ -246,7 +246,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
     }
 
     fn in_snapshot(&self) -> bool {
-        self.undo_log.borrow().len() > 0
+        !self.undo_log.borrow().is_empty()
     }
 
     pub fn start_snapshot(&self) -> RegionSnapshot {

src/librustc/middle/liveness.rs

@@ -1527,7 +1527,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
                     // for nil return types, it is ok to not return a value expl.
                 } else {
                     let ends_with_stmt = match body.expr {
-                        None if body.stmts.len() > 0 =>
+                        None if !body.stmts.is_empty() =>
                             match body.stmts.first().unwrap().node {
                                 ast::StmtSemi(ref e, _) => {
                                     ty::expr_ty(self.ir.tcx, &**e) == t_ret

src/librustc/middle/resolve_lifetime.rs

@@ -227,7 +227,7 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
                                                                                ref bounds,
                                                                                ref bound_lifetimes,
                                                                                .. }) => {
-                    if bound_lifetimes.len() > 0 {
+                    if !bound_lifetimes.is_empty() {
                         self.trait_ref_hack = true;
                         let result = self.with(LateScope(bound_lifetimes, self.scope),
                                                |old_scope, this| {
@@ -267,7 +267,7 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
                             _modifier: &ast::TraitBoundModifier) {
         debug!("visit_poly_trait_ref trait_ref={:?}", trait_ref);
 
-        if !self.trait_ref_hack || trait_ref.bound_lifetimes.len() > 0 {
+        if !self.trait_ref_hack || !trait_ref.bound_lifetimes.is_empty() {
             if self.trait_ref_hack {
                 println!("{:?}", trait_ref.span);
                 span_err!(self.sess, trait_ref.span, E0316,

src/librustc/middle/ty.rs

@@ -3713,7 +3713,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
@@ -4757,7 +4757,7 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
             match resolve_expr(tcx, expr) {
                 def::DefVariant(tid, vid, _) => {
                     let variant_info = enum_variant_with_id(tcx, tid, vid);
-                    if variant_info.args.len() > 0 {
+                    if !variant_info.args.is_empty() {
                         // N-ary variant.
                         RvalueDatumExpr
                     } else {
@@ -5352,7 +5352,7 @@ impl<'tcx> VariantInfo<'tcx> {
 
         match ast_variant.node.kind {
             ast::TupleVariantKind(ref args) => {
-                let arg_tys = if args.len() > 0 {
+                let arg_tys = if !args.is_empty() {
                     // the regions in the argument types come from the
                     // enum def'n, and hence will all be early bound
                     ty::no_late_bound_regions(cx, &ty_fn_args(ctor_ty)).unwrap()
@@ -5373,7 +5373,7 @@ impl<'tcx> VariantInfo<'tcx> {
             ast::StructVariantKind(ref struct_def) => {
                 let fields: &[StructField] = &struct_def.fields;
 
-                assert!(fields.len() > 0);
+                assert!(!fields.is_empty());
 
                 let arg_tys = struct_def.fields.iter()
                     .map(|field| node_id_to_type(cx, field.node.id)).collect();

src/librustc/util/ppaux.rs

@@ -561,7 +561,7 @@ pub fn parameterized<'tcx,GG>(cx: &ctxt<'tcx>,
                     &strs[0][..]
                 },
                 tail)
-    } else if strs.len() > 0 {
+    } else if !strs.is_empty() {
         format!("{}<{}>", base, strs.connect(", "))
     } else {
         format!("{}", base)

src/librustc_back/tempdir.rs

@@ -50,7 +50,7 @@ impl TempDir {
         let mut rng = thread_rng();
         for _ in 0..NUM_RETRIES {
             let suffix: String = rng.gen_ascii_chars().take(NUM_RAND_CHARS).collect();
-            let leaf = if prefix.len() > 0 {
+            let leaf = if !prefix.is_empty() {
                 format!("{}.{}", prefix, suffix)
             } else {
                 // If we're given an empty string for a prefix, then creating a

src/librustc_lint/builtin.rs

@@ -779,7 +779,7 @@ impl NonCamelCaseTypes {
 
             // start with a non-lowercase letter rather than non-uppercase
             // ones (some scripts don't have a concept of upper/lowercase)
-            ident.len() > 0 && !ident.char_at(0).is_lowercase() && !ident.contains('_')
+            !ident.is_empty() && !ident.char_at(0).is_lowercase() && !ident.contains('_')
         }
 
         fn to_camel_case(s: &str) -> String {
@@ -1869,7 +1869,7 @@ impl LintPass for UnconditionalRecursion {
         // doesn't return (e.g. calls a `-> !` function or `loop { /*
         // no break */ }`) shouldn't be linted unless it actually
         // recurs.
-        if !reached_exit_without_self_call && self_call_spans.len() > 0 {
+        if !reached_exit_without_self_call && !self_call_spans.is_empty() {
             cx.span_lint(UNCONDITIONAL_RECURSION, sp,
                          "function cannot return without recurring");
 

src/librustc_privacy/lib.rs

@@ -1055,7 +1055,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
         let check_inherited = |sp: Span, vis: ast::Visibility, note: &str| {
             if vis != ast::Inherited {
                 tcx.sess.span_err(sp, "unnecessary visibility qualifier");
-                if note.len() > 0 {
+                if !note.is_empty() {
                     tcx.sess.span_note(sp, note);
                 }
             }

src/librustc_resolve/lib.rs

@@ -3073,7 +3073,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             }
         }
 
-        if values.len() > 0 &&
+        if !values.is_empty() &&
             values[smallest] != usize::MAX &&
             values[smallest] < name.len() + 2 &&
             values[smallest] <= max_distance &&
@@ -3229,7 +3229,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                         format!("to call `{}::{}`", path_str, path_name)
                                 };
 
-                                if msg.len() > 0 {
+                                if !msg.is_empty() {
                                     msg = format!(". Did you mean {}?", msg)
                                 }
 

src/librustc_trans/back/link.rs

@@ -269,7 +269,7 @@ pub fn sanitize(s: &str) -> String {
     }
 
     // Underscore-qualify anything that didn't start as an ident.
-    if result.len() > 0 &&
+    if !result.is_empty() &&
         result.as_bytes()[0] != '_' as u8 &&
         ! (result.as_bytes()[0] as char).is_xid_start() {
         return format!("_{}", &result[..]);

src/librustc_trans/save/mod.rs

@@ -1119,7 +1119,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                         let glob_map = glob_map.as_ref().unwrap();
                         if glob_map.contains_key(&item.id) {
                             for n in glob_map.get(&item.id).unwrap() {
-                                if name_string.len() > 0 {
+                                if !name_string.is_empty() {
                                     name_string.push_str(", ");
                                 }
                                 name_string.push_str(n.as_str());

src/librustc_trans/trans/_match.rs

@@ -1113,7 +1113,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     let mut kind = NoBranch;
     let mut test_val = val;
     debug!("test_val={}", bcx.val_to_string(test_val));
-    if opts.len() > 0 {
+    if !opts.is_empty() {
         match opts[0] {
             ConstantValue(..) | ConstantRange(..) => {
                 test_val = load_if_immediate(bcx, val, left_ty);

src/librustc_trans/trans/base.rs

@@ -2804,7 +2804,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_trans/trans/callee.rs

@@ -183,7 +183,7 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr)
                                                     bcx.fcx.param_substs);
 
                 // Nullary variants are not callable
-                assert!(vinfo.args.len() > 0);
+                assert!(!vinfo.args.is_empty());
 
                 Callee {
                     bcx: bcx,
@@ -498,7 +498,7 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>(
 
         match map_node {
             ast_map::NodeVariant(v) => match v.node.kind {
-                ast::TupleVariantKind(ref args) => args.len() > 0,
+                ast::TupleVariantKind(ref args) => !args.is_empty(),
                 _ => false
             },
             ast_map::NodeStructCtor(_) => true,

src/librustc_trans/trans/consts.rs

@@ -677,7 +677,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                     let vinfo = ty::enum_variant_with_id(cx.tcx(),
                                                          enum_did,
                                                          variant_did);
-                    if vinfo.args.len() > 0 {
+                    if !vinfo.args.is_empty() {
                         // N-ary variant.
                         expr::trans_def_fn_unadjusted(cx, e, def, param_substs).val
                     } else {

src/librustc_trans/trans/debuginfo.rs

@@ -531,7 +531,7 @@ impl<'tcx> TypeMap<'tcx> {
             // Maybe check that there is no self type here.
 
             let tps = substs.types.get_slice(subst::TypeSpace);
-            if tps.len() > 0 {
+            if !tps.is_empty() {
                 output.push('<');
 
                 for &type_parameter in tps {
@@ -1101,7 +1101,7 @@ pub fn get_cleanup_debug_loc_for_ast_node<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         if let Ok(code_snippet) = code_snippet {
             let bytes = code_snippet.as_bytes();
 
-            if bytes.len() > 0 && &bytes[bytes.len()-1..] == b"}" {
+            if !bytes.is_empty() && &bytes[bytes.len()-1..] == b"}" {
                 cleanup_span = Span {
                     lo: node_span.hi - codemap::BytePos(1),
                     hi: node_span.hi,
@@ -3828,7 +3828,7 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             output.push_str("fn(");
 
             let sig = ty::erase_late_bound_regions(cx.tcx(), sig);
-            if sig.inputs.len() > 0 {
+            if !sig.inputs.is_empty() {
                 for &parameter_type in &sig.inputs {
                     push_debuginfo_type_name(cx, parameter_type, true, output);
                     output.push_str(", ");
@@ -3838,7 +3838,7 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             }
 
             if sig.variadic {
-                if sig.inputs.len() > 0 {
+                if !sig.inputs.is_empty() {
                     output.push_str(", ...");
                 } else {
                     output.push_str("...");

src/librustc_trans/trans/expr.rs

@@ -1259,7 +1259,7 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     match def {
         def::DefVariant(tid, vid, _) => {
             let variant_info = ty::enum_variant_with_id(bcx.tcx(), tid, vid);
-            if variant_info.args.len() > 0 {
+            if !variant_info.args.is_empty() {
                 // N-ary variant.
                 let llfn = callee::trans_fn_ref(bcx.ccx(), vid,
                                                 ExprId(ref_expr.id),