librustc: Stop using @str for source.

pcwalton · huonw · commit e68108b3e8b8 · 2014-02-02T01:44:48.000+11:00
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
@@ -138,16 +138,15 @@ fn parse_cfgspecs(cfgspecs: ~[~str], demitter: @diagnostic::Emitter)
                   -> ast::CrateConfig {
     cfgspecs.move_iter().map(|s| {
         let sess = parse::new_parse_sess(Some(demitter));
-        parse::parse_meta_from_source_str(@"cfgspec", s.to_managed(), ~[], sess)
+        parse::parse_meta_from_source_str(@"cfgspec", s, ~[], sess)
     }).collect::<ast::CrateConfig>()
 }
 
 pub enum Input {
     /// Load source from file
     FileInput(Path),
     /// The string is the source
-    // FIXME (#2319): Don't really want to box the source string
-    StrInput(@str)
+    StrInput(~str)
 }
 
 pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &Input)
@@ -157,9 +156,11 @@ pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &Input)
             FileInput(ref file) => {
                 parse::parse_crate_from_file(&(*file), cfg.clone(), sess.parse_sess)
             }
-            StrInput(src) => {
-                parse::parse_crate_from_source_str(
-                    anon_src(), src, cfg.clone(), sess.parse_sess)
+            StrInput(ref src) => {
+                parse::parse_crate_from_source_str(anon_src(),
+                                                   (*src).clone(),
+                                                   cfg.clone(),
+                                                   sess.parse_sess)
             }
         }
     })
@@ -624,7 +625,7 @@ pub fn pretty_print_input(sess: Session,
         _ => @pprust::NoAnn as @pprust::PpAnn,
     };
 
-    let src = sess.codemap.get_filemap(source_name(input)).src;
+    let src = &sess.codemap.get_filemap(source_name(input)).src;
     let mut rdr = MemReader::new(src.as_bytes().to_owned());
     let stdout = io::stdout();
     pprust::print_crate(sess.codemap,
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
@@ -236,8 +236,9 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) {
       1u => {
         let ifile = matches.free[0].as_slice();
         if "-" == ifile {
-            let src = str::from_utf8_owned(io::stdin().read_to_end()).unwrap();
-            (d::StrInput(src.to_managed()), None)
+            let src =
+                str::from_utf8_owned(io::stdin().read_to_end()).unwrap();
+            (d::StrInput(src), None)
         } else {
             (d::FileInput(Path::new(ifile)), Some(Path::new(ifile)))
         }
@@ -319,9 +320,11 @@ fn parse_crate_attrs(sess: session::Session,
         d::FileInput(ref ifile) => {
             parse::parse_crate_attrs_from_file(ifile, ~[], sess.parse_sess)
         }
-        d::StrInput(src) => {
-            parse::parse_crate_attrs_from_source_str(
-                d::anon_src(), src, ~[], sess.parse_sess)
+        d::StrInput(ref src) => {
+            parse::parse_crate_attrs_from_source_str(d::anon_src(),
+                                                     (*src).clone(),
+                                                     ~[],
+                                                     sess.parse_sess)
         }
     }
 }
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
@@ -137,7 +137,7 @@ fn runtest(test: &str, cratename: &str, libs: HashSet<Path>) {
     }
 }
 
-fn maketest(s: &str, cratename: &str) -> @str {
+fn maketest(s: &str, cratename: &str) -> ~str {
     let mut prog = ~r"
 #[deny(warnings)];
 #[allow(unused_variable, dead_assignment, unused_mut, attribute_usage, dead_code)];
@@ -156,7 +156,7 @@ fn maketest(s: &str, cratename: &str) -> @str {
         prog.push_str("\n}");
     }
 
-    return prog.to_managed();
+    return prog;
 }
 
 pub struct Collector {
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
@@ -206,7 +206,7 @@ pub struct FileMap {
     /// e.g. `<anon>`
     name: FileName,
     /// The complete source code
-    src: @str,
+    src: ~str,
     /// The start position of this source in the CodeMap
     start_pos: BytePos,
     /// Locations of lines beginnings in the source code
@@ -267,7 +267,7 @@ impl CodeMap {
         }
     }
 
-    pub fn new_filemap(&self, filename: FileName, src: @str) -> @FileMap {
+    pub fn new_filemap(&self, filename: FileName, src: ~str) -> @FileMap {
         let mut files = self.files.borrow_mut();
         let start_pos = match files.get().last() {
             None => 0,
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
@@ -1047,7 +1047,7 @@ mod test {
             ~[], sess);
         // should fail:
         let mut loader = ErrLoader;
-        expand_crate(sess,&mut loader,~[],crate_ast);
+        expand_crate(sess, &mut loader, ~[], crate_ast);
     }
 
     #[test] fn test_contains_flatten (){
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
@@ -203,7 +203,7 @@ pub mod rt {
         ($t:ty) => (
             impl ToTokens for $t {
                 fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] {
-                    cx.parse_tts(self.to_source().to_managed())
+                    cx.parse_tts(self.to_source())
                 }
             }
         )
@@ -213,7 +213,7 @@ pub mod rt {
         ($t:ty) => (
             impl<'a> ToTokens for $t {
                 fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] {
-                    cx.parse_tts(self.to_source().to_managed())
+                    cx.parse_tts(self.to_source())
                 }
             }
         )
@@ -240,15 +240,15 @@ pub mod rt {
     impl_to_tokens!(u64)
 
     pub trait ExtParseUtils {
-        fn parse_item(&self, s: @str) -> @ast::Item;
-        fn parse_expr(&self, s: @str) -> @ast::Expr;
-        fn parse_stmt(&self, s: @str) -> @ast::Stmt;
-        fn parse_tts(&self, s: @str) -> ~[ast::TokenTree];
+        fn parse_item(&self, s: ~str) -> @ast::Item;
+        fn parse_expr(&self, s: ~str) -> @ast::Expr;
+        fn parse_stmt(&self, s: ~str) -> @ast::Stmt;
+        fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree];
     }
 
     impl<'a> ExtParseUtils for ExtCtxt<'a> {
 
-        fn parse_item(&self, s: @str) -> @ast::Item {
+        fn parse_item(&self, s: ~str) -> @ast::Item {
             let res = parse::parse_item_from_source_str(
                 @"<quote expansion>",
                 s,
@@ -257,13 +257,13 @@ pub mod rt {
             match res {
                 Some(ast) => ast,
                 None => {
-                    error!("Parse error with ```\n{}\n```", s);
+                    error!("Parse error");
                     fail!()
                 }
             }
         }
 
-        fn parse_stmt(&self, s: @str) -> @ast::Stmt {
+        fn parse_stmt(&self, s: ~str) -> @ast::Stmt {
             parse::parse_stmt_from_source_str(
                 @"<quote expansion>",
                 s,
@@ -272,15 +272,15 @@ pub mod rt {
                 self.parse_sess())
         }
 
-        fn parse_expr(&self, s: @str) -> @ast::Expr {
+        fn parse_expr(&self, s: ~str) -> @ast::Expr {
             parse::parse_expr_from_source_str(
                 @"<quote expansion>",
                 s,
                 self.cfg(),
                 self.parse_sess())
         }
 
-        fn parse_tts(&self, s: @str) -> ~[ast::TokenTree] {
+        fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree] {
             parse::parse_tts_from_source_str(
                 @"<quote expansion>",
                 s,
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
@@ -114,11 +114,11 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
         Some(src) => {
             // Add this input file to the code map to make it available as
             // dependency information
-            let src = src.to_managed();
             let filename = file.display().to_str().to_managed();
+            let interned = token::intern_and_get_ident(src);
             cx.parse_sess.cm.new_filemap(filename, src);
 
-            base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(src)))
+            base::MRExpr(cx.expr_str(sp, interned))
         }
         None => {
             cx.span_err(sp, format!("{} wasn't a utf-8 file", file.display()));
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
@@ -350,7 +350,7 @@ pub fn gather_comments_and_literals(span_diagnostic:
                                     path: @str,
                                     srdr: &mut io::Reader)
                                  -> (~[Comment], ~[Literal]) {
-    let src = str::from_utf8_owned(srdr.read_to_end()).unwrap().to_managed();
+    let src = str::from_utf8_owned(srdr.read_to_end()).unwrap();
     let cm = CodeMap::new();
     let filemap = cm.new_filemap(path, src);
     let rdr = lexer::new_low_level_string_reader(span_diagnostic, filemap);
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
@@ -89,25 +89,23 @@ pub fn parse_crate_attrs_from_file(
     return inner;
 }
 
-pub fn parse_crate_from_source_str(
-    name: @str,
-    source: @str,
-    cfg: ast::CrateConfig,
-    sess: @ParseSess
-) -> ast::Crate {
+pub fn parse_crate_from_source_str(name: @str,
+                                   source: ~str,
+                                   cfg: ast::CrateConfig,
+                                   sess: @ParseSess)
+                                   -> ast::Crate {
     let mut p = new_parser_from_source_str(sess,
                                            /*bad*/ cfg.clone(),
                                            name,
                                            source);
     maybe_aborted(p.parse_crate_mod(),p)
 }
 
-pub fn parse_crate_attrs_from_source_str(
-    name: @str,
-    source: @str,
-    cfg: ast::CrateConfig,
-    sess: @ParseSess
-) -> ~[ast::Attribute] {
+pub fn parse_crate_attrs_from_source_str(name: @str,
+                                         source: ~str,
+                                         cfg: ast::CrateConfig,
+                                         sess: @ParseSess)
+                                         -> ~[ast::Attribute] {
     let mut p = new_parser_from_source_str(sess,
                                            /*bad*/ cfg.clone(),
                                            name,
@@ -116,44 +114,40 @@ pub fn parse_crate_attrs_from_source_str(
     return inner;
 }
 
-pub fn parse_expr_from_source_str(
-    name: @str,
-    source: @str,
-    cfg: ast::CrateConfig,
-    sess: @ParseSess
-) -> @ast::Expr {
+pub fn parse_expr_from_source_str(name: @str,
+                                  source: ~str,
+                                  cfg: ast::CrateConfig,
+                                  sess: @ParseSess)
+                                  -> @ast::Expr {
     let mut p = new_parser_from_source_str(sess, cfg, name, source);
     maybe_aborted(p.parse_expr(), p)
 }
 
-pub fn parse_item_from_source_str(
-    name: @str,
-    source: @str,
-    cfg: ast::CrateConfig,
-    sess: @ParseSess
-) -> Option<@ast::Item> {
+pub fn parse_item_from_source_str(name: @str,
+                                  source: ~str,
+                                  cfg: ast::CrateConfig,
+                                  sess: @ParseSess)
+                                  -> Option<@ast::Item> {
     let mut p = new_parser_from_source_str(sess, cfg, name, source);
     let attrs = p.parse_outer_attributes();
     maybe_aborted(p.parse_item(attrs),p)
 }
 
-pub fn parse_meta_from_source_str(
-    name: @str,
-    source: @str,
-    cfg: ast::CrateConfig,
-    sess: @ParseSess
-) -> @ast::MetaItem {
+pub fn parse_meta_from_source_str(name: @str,
+                                  source: ~str,
+                                  cfg: ast::CrateConfig,
+                                  sess: @ParseSess)
+                                  -> @ast::MetaItem {
     let mut p = new_parser_from_source_str(sess, cfg, name, source);
     maybe_aborted(p.parse_meta_item(),p)
 }
 
-pub fn parse_stmt_from_source_str(
-    name: @str,
-    source: @str,
-    cfg: ast::CrateConfig,
-    attrs: ~[ast::Attribute],
-    sess: @ParseSess
-) -> @ast::Stmt {
+pub fn parse_stmt_from_source_str(name: @str,
+                                  source: ~str,
+                                  cfg: ast::CrateConfig,
+                                  attrs: ~[ast::Attribute],
+                                  sess: @ParseSess)
+                                  -> @ast::Stmt {
     let mut p = new_parser_from_source_str(
         sess,
         cfg,
@@ -163,12 +157,11 @@ pub fn parse_stmt_from_source_str(
     maybe_aborted(p.parse_stmt(attrs),p)
 }
 
-pub fn parse_tts_from_source_str(
-    name: @str,
-    source: @str,
-    cfg: ast::CrateConfig,
-    sess: @ParseSess
-) -> ~[ast::TokenTree] {
+pub fn parse_tts_from_source_str(name: @str,
+                                 source: ~str,
+                                 cfg: ast::CrateConfig,
+                                 sess: @ParseSess)
+                                 -> ~[ast::TokenTree] {
     let mut p = new_parser_from_source_str(
         sess,
         cfg,
@@ -184,8 +177,8 @@ pub fn parse_tts_from_source_str(
 pub fn new_parser_from_source_str(sess: @ParseSess,
                                   cfg: ast::CrateConfig,
                                   name: @str,
-                                  source: @str)
-                               -> Parser {
+                                  source: ~str)
+                                  -> Parser {
     filemap_to_parser(sess,string_to_filemap(sess,source,name),cfg)
 }
 
@@ -248,7 +241,8 @@ pub fn file_to_filemap(sess: @ParseSess, path: &Path, spanopt: Option<Span>)
     };
     match str::from_utf8_owned(bytes) {
         Some(s) => {
-            return string_to_filemap(sess, s.to_managed(),
+            return string_to_filemap(sess,
+                                     s,
                                      path.as_str().unwrap().to_managed());
         }
         None => {
@@ -260,7 +254,7 @@ pub fn file_to_filemap(sess: @ParseSess, path: &Path, spanopt: Option<Span>)
 
 // given a session and a string, add the string to
 // the session's codemap and return the new filemap
-pub fn string_to_filemap(sess: @ParseSess, source: @str, path: @str)
+pub fn string_to_filemap(sess: @ParseSess, source: ~str, path: @str)
     -> @FileMap {
     sess.cm.new_filemap(path, source)
 }
diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs

Original file line number	Diff line number	Diff line change
`@@ -236,8 +236,9 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) {`
`236`	`236`	`1u => {`
`237`	`237`	`let ifile = matches.free[0].as_slice();`
`238`	`238`	`if "-" == ifile {`
`239`		`- let src = str::from_utf8_owned(io::stdin().read_to_end()).unwrap();`
`240`		`- (d::StrInput(src.to_managed()), None)`
	`239`	`+ let src =`
	`240`	`+ str::from_utf8_owned(io::stdin().read_to_end()).unwrap();`
	`241`	`+ (d::StrInput(src), None)`
`241`	`242`	`} else {`
`242`	`243`	`(d::FileInput(Path::new(ifile)), Some(Path::new(ifile)))`
`243`	`244`	`}`
`@@ -319,9 +320,11 @@ fn parse_crate_attrs(sess: session::Session,`
`319`	`320`	`d::FileInput(ref ifile) => {`
`320`	`321`	`parse::parse_crate_attrs_from_file(ifile, ~[], sess.parse_sess)`
`321`	`322`	`}`
`322`		`- d::StrInput(src) => {`
`323`		`- parse::parse_crate_attrs_from_source_str(`
`324`		`- d::anon_src(), src, ~[], sess.parse_sess)`
	`323`	`+ d::StrInput(ref src) => {`
	`324`	`+ parse::parse_crate_attrs_from_source_str(d::anon_src(),`
	`325`	`+ (*src).clone(),`
	`326`	`+ ~[],`
	`327`	`+ sess.parse_sess)`
`325`	`328`	`}`
`326`	`329`	`}`
`327`	`330`	`}`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ fn runtest(test: &str, cratename: &str, libs: HashSet<Path>) {`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`
`140`		`-fn maketest(s: &str, cratename: &str) -> @str {`
	`140`	`+fn maketest(s: &str, cratename: &str) -> ~str {`
`141`	`141`	`let mut prog = ~r"`
`142`	`142`	`#[deny(warnings)];`
`143`	`143`	`#[allow(unused_variable, dead_assignment, unused_mut, attribute_usage, dead_code)];`
`@@ -156,7 +156,7 @@ fn maketest(s: &str, cratename: &str) -> @str {`
`156`	`156`	`prog.push_str("\n}");`
`157`	`157`	`}`
`158`	`158`
`159`		`- return prog.to_managed();`
	`159`	`+ return prog;`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`pub struct Collector {`
Original file line number	Diff line number	Diff line change
`@@ -1047,7 +1047,7 @@ mod test {`
`1047`	`1047`	`~[], sess);`
`1048`	`1048`	`// should fail:`
`1049`	`1049`	`let mut loader = ErrLoader;`
`1050`		`- expand_crate(sess,&mut loader,~[],crate_ast);`
	`1050`	`+ expand_crate(sess, &mut loader, ~[], crate_ast);`
`1051`	`1051`	`}`
`1052`	`1052`
`1053`	`1053`	`#[test] fn test_contains_flatten (){`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ pub mod rt {`
`203`	`203`	`($t:ty) => (`
`204`	`204`	`impl ToTokens for $t {`
`205`	`205`	`fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] {`
`206`		`- cx.parse_tts(self.to_source().to_managed())`
	`206`	`+ cx.parse_tts(self.to_source())`
`207`	`207`	`}`
`208`	`208`	`}`
`209`	`209`	`)`
`@@ -213,7 +213,7 @@ pub mod rt {`
`213`	`213`	`($t:ty) => (`
`214`	`214`	`impl<'a> ToTokens for $t {`
`215`	`215`	`fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] {`
`216`		`- cx.parse_tts(self.to_source().to_managed())`
	`216`	`+ cx.parse_tts(self.to_source())`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`	`)`
`@@ -240,15 +240,15 @@ pub mod rt {`
`240`	`240`	`impl_to_tokens!(u64)`
`241`	`241`
`242`	`242`	`pub trait ExtParseUtils {`
`243`		`- fn parse_item(&self, s: @str) -> @ast::Item;`
`244`		`- fn parse_expr(&self, s: @str) -> @ast::Expr;`
`245`		`- fn parse_stmt(&self, s: @str) -> @ast::Stmt;`
`246`		`- fn parse_tts(&self, s: @str) -> ~[ast::TokenTree];`
	`243`	`+ fn parse_item(&self, s: ~str) -> @ast::Item;`
	`244`	`+ fn parse_expr(&self, s: ~str) -> @ast::Expr;`
	`245`	`+ fn parse_stmt(&self, s: ~str) -> @ast::Stmt;`
	`246`	`+ fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree];`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`impl<'a> ExtParseUtils for ExtCtxt<'a> {`
`250`	`250`
`251`		`- fn parse_item(&self, s: @str) -> @ast::Item {`
	`251`	`+ fn parse_item(&self, s: ~str) -> @ast::Item {`
`252`	`252`	`let res = parse::parse_item_from_source_str(`
`253`	`253`	`@"<quote expansion>",`
`254`	`254`	`s,`
`@@ -257,13 +257,13 @@ pub mod rt {`
`257`	`257`	`match res {`
`258`	`258`	`Some(ast) => ast,`
`259`	`259`	`None => {`
`260`		- error!("Parse error with ```\n{}\n```", s);
	`260`	`+ error!("Parse error");`
`261`	`261`	`fail!()`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`	`}`
`265`	`265`
`266`		`- fn parse_stmt(&self, s: @str) -> @ast::Stmt {`
	`266`	`+ fn parse_stmt(&self, s: ~str) -> @ast::Stmt {`
`267`	`267`	`parse::parse_stmt_from_source_str(`
`268`	`268`	`@"<quote expansion>",`
`269`	`269`	`s,`
`@@ -272,15 +272,15 @@ pub mod rt {`
`272`	`272`	`self.parse_sess())`
`273`	`273`	`}`
`274`	`274`
`275`		`- fn parse_expr(&self, s: @str) -> @ast::Expr {`
	`275`	`+ fn parse_expr(&self, s: ~str) -> @ast::Expr {`
`276`	`276`	`parse::parse_expr_from_source_str(`
`277`	`277`	`@"<quote expansion>",`
`278`	`278`	`s,`
`279`	`279`	`self.cfg(),`
`280`	`280`	`self.parse_sess())`
`281`	`281`	`}`
`282`	`282`
`283`		`- fn parse_tts(&self, s: @str) -> ~[ast::TokenTree] {`
	`283`	`+ fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree] {`
`284`	`284`	`parse::parse_tts_from_source_str(`
`285`	`285`	`@"<quote expansion>",`
`286`	`286`	`s,`