replace ConstVector trait with the Container trait

src/compiletest/runtest.rs

@@ -59,8 +59,8 @@ fn run_cfail_test(config: config, props: test_props, testfile: &Path) {
     check_correct_failure_status(procres);
 
     let expected_errors = errors::load_errors(testfile);
-    if vec::is_not_empty(expected_errors) {
-        if vec::is_not_empty(props.error_patterns) {
+    if !expected_errors.is_empty() {
+        if !props.error_patterns.is_empty() {
             fatal(~"both error pattern and expected errors specified");
         }
         check_expected_errors(expected_errors, testfile, procres);
@@ -440,7 +440,7 @@ fn compose_and_run_compiler(
     args: procargs,
     input: Option<~str>) -> procres {
 
-    if props.aux_builds.is_not_empty() {
+    if !props.aux_builds.is_empty() {
         ensure_dir(&aux_output_dir_name(config, testfile));
     }
 

src/libcore/core.rc

@@ -190,7 +190,8 @@ pub use path::PosixPath;
 
 pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
 pub use str::{StrSlice, Trimmable};
-pub use vec::{ConstVector, CopyableVector, ImmutableVector};
+pub use container::Container;
+pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector};
 pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};

src/libcore/float.rs

@@ -157,7 +157,7 @@ pub pure fn to_str_common(num: float, digits: uint, exact: bool) -> ~str {
 
     // turn digits into string
     // using stack of digits
-    while fractionalParts.is_not_empty() {
+    while !fractionalParts.is_empty() {
         // Bleh; shouldn't need to be unsafe
         let mut adjusted_digit = carry + unsafe { fractionalParts.pop() };
 

src/libcore/prelude.rs

@@ -29,7 +29,8 @@ pub use path::PosixPath;
 
 pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
 pub use str::{StrSlice, Trimmable};
-pub use vec::{ConstVector, CopyableVector, ImmutableVector};
+pub use container::Container;
+pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector};
 pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};

src/libcore/vec.rs

@@ -14,6 +14,7 @@
 #[forbid(deprecated_pattern)];
 #[warn(non_camel_case_types)];
 
+use container::Container;
 use cast::transmute;
 use cast;
 use cmp::{Eq, Ord};
@@ -453,7 +454,7 @@ pub pure fn partitioned<T: Copy>(v: &[T], f: fn(&T) -> bool) -> (~[T], ~[T]) {
 /// Removes the first element from a vector and return it
 pub fn shift<T>(v: &mut ~[T]) -> T {
     unsafe {
-        assert v.is_not_empty();
+        assert !v.is_empty();
 
         if v.len() == 1 { return v.pop() }
 
@@ -1647,20 +1648,11 @@ pub mod traits {
     }
 }
 
-pub trait ConstVector {
-    pure fn is_empty(&self) -> bool;
-    pure fn is_not_empty(&self) -> bool;
-    pure fn len(&self) -> uint;
-}
-
-/// Extension methods for vectors
-impl<T> &[const T]: ConstVector {
+impl<T> &[const T]: Container {
     /// Returns true if a vector contains no elements
     #[inline]
     pure fn is_empty(&self) -> bool { is_empty(*self) }
-    /// Returns true if a vector contains some elements
-    #[inline]
-    pure fn is_not_empty(&self) -> bool { is_not_empty(*self) }
+
     /// Returns the length of a vector
     #[inline]
     pure fn len(&self) -> uint { len(*self) }

src/librustc/front/test.rs

@@ -147,8 +147,8 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) ->
 }
 
 fn is_test_fn(i: @ast::item) -> bool {
-    let has_test_attr = attr::find_attrs_by_name(i.attrs,
-                                                 ~"test").is_not_empty();
+    let has_test_attr = !attr::find_attrs_by_name(i.attrs,
+                                                  ~"test").is_empty();
 
     fn has_test_signature(i: @ast::item) -> bool {
         match &i.node {
@@ -171,7 +171,7 @@ fn is_ignored(cx: test_ctxt, i: @ast::item) -> bool {
     let ignoreitems = attr::attr_metas(ignoreattrs);
     let cfg_metas = vec::concat(vec::filter_map(ignoreitems,
         |i| attr::get_meta_item_list(*i)));
-    return if vec::is_not_empty(ignoreitems) {
+    return if !ignoreitems.is_empty() {
         config::metas_in_cfg(/*bad*/copy cx.crate.node.config, cfg_metas)
     } else {
         false

src/librustc/lib/llvm.rs

@@ -1331,7 +1331,7 @@ fn type_to_str_inner(names: type_names, +outer0: ~[TypeRef], ty: TypeRef) ->
           Struct => {
             let n_elts = llvm::LLVMCountStructElementTypes(ty) as uint;
             let mut elts = vec::from_elem(n_elts, 0 as TypeRef);
-            if elts.is_not_empty() {
+            if !elts.is_empty() {
                 llvm::LLVMGetStructElementTypes(
                     ty, ptr::to_mut_unsafe_ptr(&mut elts[0]));
             }

src/librustc/metadata/creader.rs

@@ -95,7 +95,7 @@ fn warn_if_multiple_versions(e: env, diag: span_handler,
                 }
             }));
 
-        assert matches.is_not_empty();
+        assert !matches.is_empty();
 
         if matches.len() != 1u {
             diag.handler().warn(
@@ -168,7 +168,7 @@ fn visit_item(e: env, i: @ast::item) {
                 already_added = !cstore::add_used_library(cstore,
                                                           foreign_name);
             }
-            if link_args.is_not_empty() && already_added {
+            if !link_args.is_empty() && already_added {
                 e.diag.span_fatal(i.span, ~"library '" + foreign_name +
                            ~"' already added: can't specify link_args.");
             }

src/librustc/middle/check_match.rs

@@ -132,7 +132,7 @@ fn raw_pat(p: @pat) -> @pat {
 }
 
 fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) {
-    assert(pats.is_not_empty());
+    assert(!pats.is_empty());
     let ext = match is_useful(cx, vec::map(pats, |p| ~[*p]), ~[wild()]) {
       not_useful => return, // This is good, wildcard pattern isn't reachable
       useful_ => None,

src/librustc/middle/trans/base.rs

@@ -459,7 +459,7 @@ fn get_res_dtor(ccx: @crate_ctxt, did: ast::def_id,
                 parent_id: ast::def_id, substs: ~[ty::t])
    -> ValueRef {
     let _icx = ccx.insn_ctxt("trans_res_dtor");
-    if (substs.is_not_empty()) {
+    if !substs.is_empty() {
         let did = if did.crate != ast::local_crate {
             inline::maybe_instantiate_inline(ccx, did, true)
         } else { did };

src/librustc/middle/typeck/check/mod.rs

@@ -635,7 +635,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
         } else {
             for m.items.each |item| {
                 let tpt = ty::lookup_item_type(ccx.tcx, local_def(item.id));
-                if (*tpt.bounds).is_not_empty() {
+                if !tpt.bounds.is_empty() {
                     ccx.tcx.sess.span_err(
                         item.span,
                         fmt!("foreign items may not have type parameters"));

src/librustc/middle/typeck/mod.rs

@@ -356,7 +356,7 @@ fn check_main_fn_ty(ccx: @crate_ctxt,
                 Some(ast_map::node_item(it,_)) => {
                     match it.node {
                         ast::item_fn(_, _, ref ps, _)
-                        if vec::is_not_empty(*ps) => {
+                        if !ps.is_empty() => {
                             tcx.sess.span_err(
                                 main_span,
                                 ~"main function is not allowed \

src/libstd/bigint.rs

@@ -402,7 +402,7 @@ pub impl BigUint {
     }
 
     pure fn is_zero(&self) -> bool { self.data.is_empty() }
-    pure fn is_not_zero(&self) -> bool { self.data.is_not_empty() }
+    pure fn is_not_zero(&self) -> bool { !self.data.is_empty() }
     pure fn is_positive(&self) -> bool { self.is_not_zero() }
     pure fn is_negative(&self) -> bool { false }
     pure fn is_nonpositive(&self) -> bool { self.is_zero() }

src/libstd/flatpipes.rs

@@ -599,7 +599,7 @@ pub mod bytepipes {
             } else if self.buf.is_empty() {
                 match self.port.try_recv() {
                     Some(move buf) => {
-                        assert buf.is_not_empty();
+                        assert !buf.is_empty();
                         self.buf = move buf;
                         return self.try_recv(count);
                     }
@@ -904,7 +904,7 @@ mod test {
         fn pipe_port_loader(bytes: ~[u8]
                            ) -> pod::PipePort<int> {
             let (port, chan) = pipes::stream();
-            if bytes.is_not_empty() {
+            if !bytes.is_empty() {
                 chan.send(move bytes);
             }
             pod::pipe_port(move port)

src/libstd/getopts.rs

@@ -45,7 +45,7 @@
  *     }
  *
  *     fn main(args: ~[str]) {
- *         check vec::is_not_empty(args);
+ *         check !args.is_empty()
  *
  *         let program : str = vec::head(args);
  *
@@ -63,7 +63,7 @@
  *             return;
  *         }
  *         let output = opt_maybe_str(matches, "o");
- *         let input = if vec::is_not_empty(matches.free) {
+ *         let input = if !matches.free.is_empty() {
  *             matches.free[0]
  *         } else {
  *             print_usage(program);
@@ -357,7 +357,7 @@ fn opt_val(mm: &Matches, nm: &str) -> Optval { return opt_vals(mm, nm)[0]; }
 
 /// Returns true if an option was matched
 pub fn opt_present(mm: &Matches, nm: &str) -> bool {
-    opt_vals(mm, nm).is_not_empty()
+    !opt_vals(mm, nm).is_empty()
 }
 
 /// Returns the number of times an option was matched

src/libsyntax/print/pprust.rs

@@ -532,7 +532,7 @@ fn print_item(s: ps, &&item: @ast::item) {
 
       ast::item_impl(tps, opt_trait, ty, methods) => {
         head(s, visibility_qualified(item.vis, ~"impl"));
-        if tps.is_not_empty() {
+        if !tps.is_empty() {
             print_type_params(s, tps);
             space(s.s);
         }
@@ -770,7 +770,7 @@ fn print_variant(s: ps, v: ast::variant) {
     match v.node.kind {
         ast::tuple_variant_kind(args) => {
             print_ident(s, v.node.name);
-            if args.is_not_empty() {
+            if !args.is_empty() {
                 popen(s);
                 fn print_variant_arg(s: ps, arg: ast::variant_arg) {
                     print_type(s, arg.ty);
@@ -1054,7 +1054,7 @@ fn print_call_post(s: ps,
                    has_block: bool,
                    blk: &Option<@ast::expr>,
                    base_args: &mut ~[@ast::expr]) {
-    if !has_block || base_args.is_not_empty() {
+    if !has_block || !base_args.is_empty() {
         popen(s);
         commasep_exprs(s, inconsistent, *base_args);
         pclose(s);
@@ -1564,7 +1564,7 @@ fn print_pat(s: ps, &&pat: @ast::pat, refutable: bool) {
         match args_ {
           None => word(s.s, ~"(*)"),
           Some(args) => {
-            if args.is_not_empty() {
+            if !args.is_empty() {
               popen(s);
               commasep(s, inconsistent, args,
                        |s, p| print_pat(s, p, refutable));
@@ -1762,7 +1762,7 @@ fn print_arg_mode(s: ps, m: ast::mode) {
 }
 
 fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) {
-    if bounds.is_not_empty() {
+    if !bounds.is_empty() {
         word(s.s, ~":");
         let mut first = true;
         for vec::each(*bounds) |&bound| {
@@ -1855,7 +1855,7 @@ fn print_view_item(s: ps, item: @ast::view_item) {
       ast::view_item_use(id, mta, _) => {
         head(s, ~"extern mod");
         print_ident(s, id);
-        if mta.is_not_empty() {
+        if !mta.is_empty() {
             popen(s);
             commasep(s, consistent, mta, print_meta_item);
             pclose(s);
@@ -2101,7 +2101,7 @@ fn print_comment(s: ps, cmnt: comments::cmnt) {
         for cmnt.lines.each |line| {
             // Don't print empty lines because they will end up as trailing
             // whitespace
-            if str::is_not_empty(*line) { word(s.s, *line); }
+            if !line.is_empty() { word(s.s, *line); }
             hardbreak(s.s);
         }
       }
@@ -2113,7 +2113,7 @@ fn print_comment(s: ps, cmnt: comments::cmnt) {
         } else {
             ibox(s, 0u);
             for cmnt.lines.each |line| {
-                if str::is_not_empty(*line) { word(s.s, *line); }
+                if !line.is_empty() { word(s.s, *line); }
                 hardbreak(s.s);
             }
             end(s);