Remove all unnecessary allocations (as flagged by lint)

10 files changed, 60 insertions, 60 deletions

diff --git a/src/libstd/dlist.rs b/src/libstd/dlist.rs
index 100543d7d98..57cd03e16a0 100644
--- a/src/libstd/dlist.rs
+++ b/src/libstd/dlist.rs
@@ -136,10 +136,10 @@ priv impl<T> DList<T> {
         }
         if !nobe.linked { fail!("That node isn't linked to any dlist.") }
         if !((nobe.prev.is_some()
-              || managed::mut_ptr_eq(self.hd.expect(~"headless dlist?"),
+              || managed::mut_ptr_eq(self.hd.expect("headless dlist?"),
                                  nobe)) &&
              (nobe.next.is_some()
-              || managed::mut_ptr_eq(self.tl.expect(~"tailless dlist?"),
+              || managed::mut_ptr_eq(self.tl.expect("tailless dlist?"),
                                  nobe))) {
             fail!("That node isn't on this dlist.")
         }
@@ -514,10 +514,10 @@ impl<T> BaseIter<T> for @mut DList<T> {
             }
             if !nobe.linked ||
                 (!((nobe.prev.is_some()
-                    || managed::mut_ptr_eq(self.hd.expect(~"headless dlist?"),
+                    || managed::mut_ptr_eq(self.hd.expect("headless dlist?"),
                                            nobe))
                    && (nobe.next.is_some()
-                    || managed::mut_ptr_eq(self.tl.expect(~"tailless dlist?"),
+                    || managed::mut_ptr_eq(self.tl.expect("tailless dlist?"),
                                            nobe)))) {
                 fail!("Removing a dlist node during iteration is forbidden!")
             }
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index d0b298deb89..6a9a60baae6 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -587,7 +587,7 @@ pub mod groups {
      */
     pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str {
 
-        let desc_sep = ~"\n" + str::repeat(~" ", 24);
+        let desc_sep = ~"\n" + str::repeat(" ", 24);
 
         let rows = vec::map(opts, |optref| {
             let OptGroup{short_name: short_name,
@@ -597,7 +597,7 @@ pub mod groups {
                          hasarg: hasarg,
                          _} = copy *optref;
 
-            let mut row = str::repeat(~" ", 4);
+            let mut row = str::repeat(" ", 4);
 
             // short option
             row += match short_name.len() {
@@ -623,7 +623,7 @@ pub mod groups {
             // here we just need to indent the start of the description
             let rowlen = row.len();
             row += if rowlen < 24 {
-                str::repeat(~" ", 24 - rowlen)
+                str::repeat(" ", 24 - rowlen)
             } else {
                 copy desc_sep
             };
@@ -650,7 +650,7 @@ pub mod groups {
 
         return str::to_owned(brief)    +
                ~"\n\nOptions:\n"         +
-               str::connect(rows, ~"\n") +
+               str::connect(rows, "\n") +
                ~"\n\n";
     }
 } // end groups module
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 270cf675c87..44e965b5c43 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -524,9 +524,9 @@ priv impl Parser {
         if self.eof() { return self.error(~"EOF while parsing value"); }
 
         match self.ch {
-          'n' => self.parse_ident(~"ull", Null),
-          't' => self.parse_ident(~"rue", Boolean(true)),
-          'f' => self.parse_ident(~"alse", Boolean(false)),
+          'n' => self.parse_ident("ull", Null),
+          't' => self.parse_ident("rue", Boolean(true)),
+          'f' => self.parse_ident("alse", Boolean(false)),
           '0' .. '9' | '-' => self.parse_number(),
           '"' =>
             match self.parse_str() {
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index 19cd418915e..da81f730eda 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -26,7 +26,7 @@ pub fn md4(msg: &[u8]) -> Quad {
     let orig_len: u64 = (msg.len() * 8u) as u64;
 
     // pad message
-    let mut msg = vec::append(vec::to_owned(msg), ~[0x80u8]);
+    let mut msg = vec::append(vec::to_owned(msg), [0x80u8]);
     let mut bitlen = orig_len + 8u64;
     while (bitlen + 64u64) % 512u64 > 0u64 {
         msg.push(0u8);
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 19e0dc14412..fb57c717be9 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -350,7 +350,7 @@ pub fn query_to_str(query: &Query) -> ~str {
             }
         }
     }
-    return str::connect(strvec, ~"&");
+    return str::connect(strvec, "&");
 }
 
 // returns the scheme and the rest of the url, or a parsing error
@@ -390,7 +390,7 @@ enum Input {
 // returns userinfo, host, port, and unparsed part, or an error
 fn get_authority(rawurl: &str) ->
     Result<(Option<UserInfo>, ~str, Option<~str>, ~str), ~str> {
-    if !str::starts_with(rawurl, ~"//") {
+    if !str::starts_with(rawurl, "//") {
         // there is no authority.
         return Ok((None, ~"", None, rawurl.to_str()));
     }
@@ -575,7 +575,7 @@ fn get_path(rawurl: &str, authority: bool) ->
     }
 
     if authority {
-        if end != 0 && !str::starts_with(rawurl, ~"/") {
+        if end != 0 && !str::starts_with(rawurl, "/") {
             return Err(~"Non-empty path must begin with\
                                '/' in presence of authority.");
         }
@@ -588,8 +588,8 @@ fn get_path(rawurl: &str, authority: bool) ->
 // returns the parsed query and the fragment, if present
 fn get_query_fragment(rawurl: &str) ->
     Result<(Query, Option<~str>), ~str> {
-    if !str::starts_with(rawurl, ~"?") {
-        if str::starts_with(rawurl, ~"#") {
+    if !str::starts_with(rawurl, "?") {
+        if str::starts_with(rawurl, "#") {
             let f = decode_component(str::slice(rawurl,
                                                 1,
                                                 str::len(rawurl)).to_owned());
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 925f79b66c9..04444789f82 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -106,7 +106,7 @@ Section: Adding things to a rope
  * * this function executes in near-constant time
  */
 pub fn append_char(rope: Rope, char: char) -> Rope {
-    return append_str(rope, @str::from_chars(~[char]));
+    return append_str(rope, @str::from_chars([char]));
 }
 
 /**
@@ -127,7 +127,7 @@ pub fn append_str(rope: Rope, str: @~str) -> Rope {
  * * this function executes in near-constant time
  */
 pub fn prepend_char(rope: Rope, char: char) -> Rope {
-    return prepend_str(rope, @str::from_chars(~[char]));
+    return prepend_str(rope, @str::from_chars([char]));
 }
 
 /**
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index bb3be8a55ea..d7051d73469 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -177,7 +177,7 @@ pub fn sha1() -> @Sha1 {
             let b = (hpart >> 16u32 & 0xFFu32) as u8;
             let c = (hpart >> 8u32 & 0xFFu32) as u8;
             let d = (hpart & 0xFFu32) as u8;
-            rs = vec::append(copy rs, ~[a, b, c, d]);
+            rs = vec::append(copy rs, [a, b, c, d]);
         }
         return rs;
     }
diff --git a/src/libstd/term.rs b/src/libstd/term.rs
index 236c7f668c2..fcac7062210 100644
--- a/src/libstd/term.rs
+++ b/src/libstd/term.rs
@@ -35,19 +35,19 @@ pub static color_bright_magenta: u8 = 13u8;
 pub static color_bright_cyan: u8 = 14u8;
 pub static color_bright_white: u8 = 15u8;
 
-pub fn esc(writer: @io::Writer) { writer.write(~[0x1bu8, '[' as u8]); }
+pub fn esc(writer: @io::Writer) { writer.write([0x1bu8, '[' as u8]); }
 
 /// Reset the foreground and background colors to default
 pub fn reset(writer: @io::Writer) {
     esc(writer);
-    writer.write(~['0' as u8, 'm' as u8]);
+    writer.write(['0' as u8, 'm' as u8]);
 }
 
 /// Returns true if the terminal supports color
 pub fn color_supported() -> bool {
     let supported_terms = ~[~"xterm-color", ~"xterm",
                            ~"screen-bce", ~"xterm-256color"];
-    return match os::getenv(~"TERM") {
+    return match os::getenv("TERM") {
           option::Some(ref env) => {
             for supported_terms.each |term| {
                 if *term == *env { return true; }
@@ -62,8 +62,8 @@ pub fn set_color(writer: @io::Writer, first_char: u8, color: u8) {
     assert!((color < 16u8));
     esc(writer);
     let mut color = color;
-    if color >= 8u8 { writer.write(~['1' as u8, ';' as u8]); color -= 8u8; }
-    writer.write(~[first_char, ('0' as u8) + color, 'm' as u8]);
+    if color >= 8u8 { writer.write(['1' as u8, ';' as u8]); color -= 8u8; }
+    writer.write([first_char, ('0' as u8) + color, 'm' as u8]);
 }
 
 /// Set the foreground color
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index e9fd4e9a2b8..4046ce83c9d 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -131,12 +131,12 @@ type OptRes = Either<TestOpts, ~str>;
 // Parses command line arguments into test options
 pub fn parse_opts(args: &[~str]) -> OptRes {
     let args_ = vec::tail(args);
-    let opts = ~[getopts::optflag(~"ignored"),
-                 getopts::optflag(~"test"),
-                 getopts::optflag(~"bench"),
-                 getopts::optopt(~"save"),
-                 getopts::optopt(~"diff"),
-                 getopts::optopt(~"logfile")];
+    let opts = ~[getopts::optflag("ignored"),
+                 getopts::optflag("test"),
+                 getopts::optflag("bench"),
+                 getopts::optopt("save"),
+                 getopts::optopt("diff"),
+                 getopts::optopt("logfile")];
     let matches =
         match getopts::getopts(args_, opts) {
           Ok(m) => m,
@@ -148,19 +148,19 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
             option::Some(copy (matches).free[0])
         } else { option::None };
 
-    let run_ignored = getopts::opt_present(&matches, ~"ignored");
+    let run_ignored = getopts::opt_present(&matches, "ignored");
 
-    let logfile = getopts::opt_maybe_str(&matches, ~"logfile");
+    let logfile = getopts::opt_maybe_str(&matches, "logfile");
     let logfile = logfile.map(|s| Path(*s));
 
-    let run_benchmarks = getopts::opt_present(&matches, ~"bench");
+    let run_benchmarks = getopts::opt_present(&matches, "bench");
     let run_tests = ! run_benchmarks ||
-        getopts::opt_present(&matches, ~"test");
+        getopts::opt_present(&matches, "test");
 
-    let save_results = getopts::opt_maybe_str(&matches, ~"save");
+    let save_results = getopts::opt_maybe_str(&matches, "save");
     let save_results = save_results.map(|s| Path(*s));
 
-    let compare_results = getopts::opt_maybe_str(&matches, ~"diff");
+    let compare_results = getopts::opt_maybe_str(&matches, "diff");
     let compare_results = compare_results.map(|s| Path(*s));
 
     let test_opts = TestOpts {
@@ -220,18 +220,18 @@ pub fn run_tests_console(opts: &TestOpts,
               TrOk => {
                 st.passed += 1;
                 write_ok(st.out, st.use_color);
-                st.out.write_line(~"");
+                st.out.write_line("");
               }
               TrFailed => {
                 st.failed += 1;
                 write_failed(st.out, st.use_color);
-                st.out.write_line(~"");
+                st.out.write_line("");
                 st.failures.push(test);
               }
               TrIgnored => {
                 st.ignored += 1;
                 write_ignored(st.out, st.use_color);
-                st.out.write_line(~"");
+                st.out.write_line("");
               }
               TrBench(bs) => {
                 st.benchmarked += 1u;
@@ -246,8 +246,8 @@ pub fn run_tests_console(opts: &TestOpts,
 
     let log_out = match opts.logfile {
         Some(ref path) => match io::file_writer(path,
-                                                ~[io::Create,
-                                                  io::Truncate]) {
+                                                [io::Create,
+                                                 io::Truncate]) {
           result::Ok(w) => Some(w),
           result::Err(ref s) => {
               fail!("can't open output file: %s", *s)
@@ -318,19 +318,19 @@ pub fn run_tests_console(opts: &TestOpts,
     }
 
     fn write_ok(out: @io::Writer, use_color: bool) {
-        write_pretty(out, ~"ok", term::color_green, use_color);
+        write_pretty(out, "ok", term::color_green, use_color);
     }
 
     fn write_failed(out: @io::Writer, use_color: bool) {
-        write_pretty(out, ~"FAILED", term::color_red, use_color);
+        write_pretty(out, "FAILED", term::color_red, use_color);
     }
 
     fn write_ignored(out: @io::Writer, use_color: bool) {
-        write_pretty(out, ~"ignored", term::color_yellow, use_color);
+        write_pretty(out, "ignored", term::color_yellow, use_color);
     }
 
     fn write_bench(out: @io::Writer, use_color: bool) {
-        write_pretty(out, ~"bench", term::color_cyan, use_color);
+        write_pretty(out, "bench", term::color_cyan, use_color);
     }
 
     fn write_pretty(out: @io::Writer,
@@ -348,7 +348,7 @@ pub fn run_tests_console(opts: &TestOpts,
 }
 
 fn print_failures(st: &ConsoleTestState) {
-    st.out.write_line(~"\nfailures:");
+    st.out.write_line("\nfailures:");
     let mut failures = ~[];
     for uint::range(0, vec::uniq_len(&const st.failures)) |i| {
         let name = copy st.failures[i].name;
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 9e6a45137a4..565ce2d0dd3 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -199,7 +199,7 @@ pub impl Tm {
      * Return a string of the current time in the form
      * "Thu Jan  1 00:00:00 1970".
      */
-    fn ctime(&self) -> ~str { self.strftime(~"%c") }
+    fn ctime(&self) -> ~str { self.strftime("%c") }
 
     /// Formats the time according to the format string.
     fn strftime(&self, format: &str) -> ~str {
@@ -214,9 +214,9 @@ pub impl Tm {
      */
     fn rfc822(&self) -> ~str {
         if self.tm_gmtoff == 0_i32 {
-            self.strftime(~"%a, %d %b %Y %T GMT")
+            self.strftime("%a, %d %b %Y %T GMT")
         } else {
-            self.strftime(~"%a, %d %b %Y %T %Z")
+            self.strftime("%a, %d %b %Y %T %Z")
         }
     }
 
@@ -227,7 +227,7 @@ pub impl Tm {
      * utc:   "Thu, 22 Mar 2012 14:53:18 -0000"
      */
     fn rfc822z(&self) -> ~str {
-        self.strftime(~"%a, %d %b %Y %T %z")
+        self.strftime("%a, %d %b %Y %T %z")
     }
 
     /**
@@ -238,9 +238,9 @@ pub impl Tm {
      */
     fn rfc3339(&self) -> ~str {
         if self.tm_gmtoff == 0_i32 {
-            self.strftime(~"%Y-%m-%dT%H:%M:%SZ")
+            self.strftime("%Y-%m-%dT%H:%M:%SZ")
         } else {
-            let s = self.strftime(~"%Y-%m-%dT%H:%M:%S");
+            let s = self.strftime("%Y-%m-%dT%H:%M:%S");
             let sign = if self.tm_gmtoff > 0_i32 { '+' } else { '-' };
             let mut m = i32::abs(self.tm_gmtoff) / 60_i32;
             let h = m / 60_i32;
@@ -326,7 +326,7 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
     fn parse_type(s: &str, pos: uint, ch: char, tm: &mut Tm)
       -> Result<uint, ~str> {
         match ch {
-          'A' => match match_strs(s, pos, ~[
+          'A' => match match_strs(s, pos, [
               (~"Sunday", 0_i32),
               (~"Monday", 1_i32),
               (~"Tuesday", 2_i32),
@@ -338,7 +338,7 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
             Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
             None => Err(~"Invalid day")
           },
-          'a' => match match_strs(s, pos, ~[
+          'a' => match match_strs(s, pos, [
               (~"Sun", 0_i32),
               (~"Mon", 1_i32),
               (~"Tue", 2_i32),
@@ -350,7 +350,7 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
             Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
             None => Err(~"Invalid day")
           },
-          'B' => match match_strs(s, pos, ~[
+          'B' => match match_strs(s, pos, [
               (~"January", 0_i32),
               (~"February", 1_i32),
               (~"March", 2_i32),
@@ -367,7 +367,7 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
             Some(item) => { let (v, pos) = item; tm.tm_mon = v; Ok(pos) }
             None => Err(~"Invalid month")
           },
-          'b' | 'h' => match match_strs(s, pos, ~[
+          'b' | 'h' => match match_strs(s, pos, [
               (~"Jan", 0_i32),
               (~"Feb", 1_i32),
               (~"Mar", 2_i32),
@@ -488,13 +488,13 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
           }
           'n' => parse_char(s, pos, '\n'),
           'P' => match match_strs(s, pos,
-                                  ~[(~"am", 0_i32), (~"pm", 12_i32)]) {
+                                  [(~"am", 0_i32), (~"pm", 12_i32)]) {
 
             Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) }
             None => Err(~"Invalid hour")
           },
           'p' => match match_strs(s, pos,
-                                  ~[(~"AM", 0_i32), (~"PM", 12_i32)]) {
+                                  [(~"AM", 0_i32), (~"PM", 12_i32)]) {
 
             Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) }
             None => Err(~"Invalid hour")
@@ -579,7 +579,7 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
             }
           }
           'Z' => {
-            if match_str(s, pos, ~"UTC") || match_str(s, pos, ~"GMT") {
+            if match_str(s, pos, "UTC") || match_str(s, pos, "GMT") {
                 tm.tm_gmtoff = 0_i32;
                 tm.tm_zone = ~"UTC";
                 Ok(pos + 3u)