Move the world over to using the new style string literals and types. Closes #2907.

1 files changed, 40 insertions, 40 deletions

diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index aa3e808f63e..737307bb648 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -18,28 +18,28 @@ enum cmnt_style {
     blank_line, // Just a manual blank line "\n\n", for layout
 }
 
-type cmnt = {style: cmnt_style, lines: ~[str], pos: uint};
+type cmnt = {style: cmnt_style, lines: ~[~str], pos: uint};
 
-fn is_doc_comment(s: str) -> bool {
-    s.starts_with("///") ||
-    s.starts_with("//!") ||
-    s.starts_with("/**") ||
-    s.starts_with("/*!")
+fn is_doc_comment(s: ~str) -> bool {
+    s.starts_with(~"///") ||
+    s.starts_with(~"//!") ||
+    s.starts_with(~"/**") ||
+    s.starts_with(~"/*!")
 }
 
-fn doc_comment_style(comment: str) -> ast::attr_style {
+fn doc_comment_style(comment: ~str) -> ast::attr_style {
     assert is_doc_comment(comment);
-    if comment.starts_with("//!") || comment.starts_with("/*!") {
+    if comment.starts_with(~"//!") || comment.starts_with(~"/*!") {
         ast::attr_inner
     } else {
         ast::attr_outer
     }
 }
 
-fn strip_doc_comment_decoration(comment: str) -> str {
+fn strip_doc_comment_decoration(comment: ~str) -> ~str {
 
     /// remove whitespace-only lines from the start/end of lines
-    fn vertical_trim(lines: ~[str]) -> ~[str] {
+    fn vertical_trim(lines: ~[~str]) -> ~[~str] {
         let mut i = 0u, j = lines.len();
         while i < j && lines[i].trim().is_empty() {
             i += 1u;
@@ -51,7 +51,7 @@ fn strip_doc_comment_decoration(comment: str) -> str {
     }
 
     // drop leftmost columns that contain only values in chars
-    fn block_trim(lines: ~[str], chars: str, max: option<uint>) -> ~[str] {
+    fn block_trim(lines: ~[~str], chars: ~str, max: option<uint>) -> ~[~str] {
 
         let mut i = max.get_default(uint::max_value);
         for lines.each |line| {
@@ -72,31 +72,31 @@ fn strip_doc_comment_decoration(comment: str) -> str {
         ret do lines.map |line| {
             let chars = str::chars(line);
             if i > chars.len() {
-                ""
+                ~""
             } else {
                 str::from_chars(chars.slice(i, chars.len()))
             }
         };
     }
 
-    if comment.starts_with("//") {
+    if comment.starts_with(~"//") {
         ret comment.slice(3u, comment.len()).trim();
     }
 
-    if comment.starts_with("/*") {
+    if comment.starts_with(~"/*") {
         let lines = str::lines_any(comment.slice(3u, comment.len() - 2u));
         let lines = vertical_trim(lines);
-        let lines = block_trim(lines, "\t ", none);
-        let lines = block_trim(lines, "*", some(1u));
-        let lines = block_trim(lines, "\t ", none);
-        ret str::connect(lines, "\n");
+        let lines = block_trim(lines, ~"\t ", none);
+        let lines = block_trim(lines, ~"*", some(1u));
+        let lines = block_trim(lines, ~"\t ", none);
+        ret str::connect(lines, ~"\n");
     }
 
-    fail "not a doc-comment: " + comment;
+    fail ~"not a doc-comment: " + comment;
 }
 
-fn read_to_eol(rdr: string_reader) -> str {
-    let mut val = "";
+fn read_to_eol(rdr: string_reader) -> ~str {
+    let mut val = ~"";
     while rdr.curr != '\n' && !is_eof(rdr) {
         str::push_char(val, rdr.curr);
         bump(rdr);
@@ -105,7 +105,7 @@ fn read_to_eol(rdr: string_reader) -> str {
     ret val;
 }
 
-fn read_one_line_comment(rdr: string_reader) -> str {
+fn read_one_line_comment(rdr: string_reader) -> ~str {
     let val = read_to_eol(rdr);
     assert ((val[0] == '/' as u8 && val[1] == '/' as u8) ||
             (val[0] == '#' as u8 && val[1] == '!' as u8));
@@ -120,7 +120,7 @@ fn consume_non_eol_whitespace(rdr: string_reader) {
 
 fn push_blank_line_comment(rdr: string_reader, &comments: ~[cmnt]) {
     #debug(">>> blank-line comment");
-    let v: ~[str] = ~[];
+    let v: ~[~str] = ~[];
     vec::push(comments, {style: blank_line, lines: v, pos: rdr.chpos});
 }
 
@@ -151,7 +151,7 @@ fn read_line_comments(rdr: string_reader, code_to_the_left: bool,
                                                         &comments: ~[cmnt]) {
     #debug(">>> line comments");
     let p = rdr.chpos;
-    let mut lines: ~[str] = ~[];
+    let mut lines: ~[~str] = ~[];
     while rdr.curr == '/' && nextch(rdr) == '/' {
         let line = read_one_line_comment(rdr);
         log(debug, line);
@@ -171,22 +171,22 @@ fn read_line_comments(rdr: string_reader, code_to_the_left: bool,
     }
 }
 
-fn all_whitespace(s: str, begin: uint, end: uint) -> bool {
+fn all_whitespace(s: ~str, begin: uint, end: uint) -> bool {
     let mut i: uint = begin;
     while i != end { if !is_whitespace(s[i] as char) { ret false; } i += 1u; }
     ret true;
 }
 
-fn trim_whitespace_prefix_and_push_line(&lines: ~[str],
-                                        s: str, col: uint) unsafe {
+fn trim_whitespace_prefix_and_push_line(&lines: ~[~str],
+                                        s: ~str, col: uint) unsafe {
     let mut s1;
     let len = str::len(s);
     if all_whitespace(s, 0u, uint::min(len, col)) {
         if col < len {
             s1 = str::slice(s, col, len);
-        } else { s1 = ""; }
+        } else { s1 = ~""; }
     } else { s1 = s; }
-    log(debug, "pushing line: " + s1);
+    log(debug, ~"pushing line: " + s1);
     vec::push(lines, s1);
 }
 
@@ -194,7 +194,7 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool,
                                                         &comments: ~[cmnt]) {
     #debug(">>> block comment");
     let p = rdr.chpos;
-    let mut lines: ~[str] = ~[];
+    let mut lines: ~[~str] = ~[];
     let mut col: uint = rdr.col;
     bump(rdr);
     bump(rdr);
@@ -211,27 +211,27 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool,
         ret;
     }
 
-    let mut curr_line = "/*";
+    let mut curr_line = ~"/*";
     let mut level: int = 1;
     while level > 0 {
         #debug("=== block comment level %d", level);
-        if is_eof(rdr) {(rdr as reader).fatal("unterminated block comment");}
+        if is_eof(rdr) {(rdr as reader).fatal(~"unterminated block comment");}
         if rdr.curr == '\n' {
             trim_whitespace_prefix_and_push_line(lines, curr_line, col);
-            curr_line = "";
+            curr_line = ~"";
             bump(rdr);
         } else {
             str::push_char(curr_line, rdr.curr);
             if rdr.curr == '/' && nextch(rdr) == '*' {
                 bump(rdr);
                 bump(rdr);
-                curr_line += "*";
+                curr_line += ~"*";
                 level += 1;
             } else {
                 if rdr.curr == '*' && nextch(rdr) == '/' {
                     bump(rdr);
                     bump(rdr);
-                    curr_line += "/";
+                    curr_line += ~"/";
                     level -= 1;
                 } else { bump(rdr); }
             }
@@ -268,14 +268,14 @@ fn consume_comment(rdr: string_reader, code_to_the_left: bool,
     #debug("<<< consume comment");
 }
 
-type lit = {lit: str, pos: uint};
+type lit = {lit: ~str, pos: uint};
 
 fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
-                                path: str,
+                                path: ~str,
                                 srdr: io::reader) ->
    {cmnts: ~[cmnt], lits: ~[lit]} {
     let src = @str::from_bytes(srdr.read_whole_stream());
-    let itr = @interner::mk::<@str/~>(
+    let itr = @interner::mk::<@~str>(
         |x| str::hash(*x),
         |x,y| str::eq(*x, *y)
     );
@@ -308,9 +308,9 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
         if token::is_lit(tok) {
             let s = get_str_from(rdr, bstart);
             vec::push(literals, {lit: s, pos: sp.lo});
-            log(debug, "tok lit: " + s);
+            log(debug, ~"tok lit: " + s);
         } else {
-            log(debug, "tok: " + token::to_str(*rdr.interner, tok));
+            log(debug, ~"tok: " + token::to_str(*rdr.interner, tok));
         }
         first_read = false;
     }