De-@ ParseSess uses.

Author: eddyb

src/librustc/driver/driver.rs

@@ -146,11 +146,10 @@ pub fn build_configuration(sess: &Session) -> ast::CrateConfig {
 fn parse_cfgspecs(cfgspecs: Vec<~str> )
                   -> ast::CrateConfig {
     cfgspecs.move_iter().map(|s| {
-        let sess = parse::new_parse_sess();
         parse::parse_meta_from_source_str("cfgspec".to_str(),
                                           s,
                                           Vec::new(),
-                                          sess)
+                                          &parse::new_parse_sess())
     }).collect::<ast::CrateConfig>()
 }
 
@@ -175,13 +174,13 @@ pub fn phase_1_parse_input(sess: &Session, cfg: ast::CrateConfig, input: &Input)
     let krate = time(sess.time_passes(), "parsing", (), |_| {
         match *input {
             FileInput(ref file) => {
-                parse::parse_crate_from_file(&(*file), cfg.clone(), sess.parse_sess)
+                parse::parse_crate_from_file(&(*file), cfg.clone(), &sess.parse_sess)
             }
             StrInput(ref src) => {
                 parse::parse_crate_from_source_str(anon_src(),
                                                    (*src).clone(),
                                                    cfg.clone(),
-                                                   sess.parse_sess)
+                                                   &sess.parse_sess)
             }
         }
     });
@@ -241,7 +240,7 @@ pub fn phase_2_configure_and_expand(sess: &Session,
             deriving_hash_type_parameter: sess.features.default_type_params.get(),
             crate_id: crate_id.clone(),
         };
-        syntax::ext::expand::expand_crate(sess.parse_sess,
+        syntax::ext::expand::expand_crate(&sess.parse_sess,
                                           cfg,
                                           krate)
     });

src/librustc/driver/session.rs

@@ -177,7 +177,7 @@ pub struct Session {
     targ_cfg: @Config,
     opts: @Options,
     cstore: metadata::cstore::CStore,
-    parse_sess: @ParseSess,
+    parse_sess: ParseSess,
     codemap: @codemap::CodeMap,
     // For a library crate, this is always none
     entry_fn: RefCell<Option<(NodeId, codemap::Span)>>,

src/librustc/front/test.rs

@@ -166,7 +166,7 @@ fn generate_test_harness(sess: &Session, krate: ast::Crate)
     let loader = &mut Loader::new(sess);
     let mut cx: TestCtxt = TestCtxt {
         sess: sess,
-        ext_cx: ExtCtxt::new(sess.parse_sess, sess.opts.cfg.clone(),
+        ext_cx: ExtCtxt::new(&sess.parse_sess, sess.opts.cfg.clone(),
                              ExpansionConfig {
                                  loader: loader,
                                  deriving_hash_type_parameter: false,

src/librustc/lib.rs

@@ -350,13 +350,13 @@ fn parse_crate_attrs(sess: &session::Session, input: &d::Input) ->
         d::FileInput(ref ifile) => {
             parse::parse_crate_attrs_from_file(ifile,
                                                Vec::new(),
-                                               sess.parse_sess)
+                                               &sess.parse_sess)
         }
         d::StrInput(ref src) => {
             parse::parse_crate_attrs_from_source_str(d::anon_src(),
                                                      (*src).clone(),
                                                      Vec::new(),
-                                                     sess.parse_sess)
+                                                     &sess.parse_sess)
         }
     };
     result.move_iter().collect()

src/librustc/middle/astencode.rs

@@ -1446,17 +1446,17 @@ fn decode_item_ast(par_doc: ebml::Doc) -> @ast::Item {
 #[cfg(test)]
 trait fake_ext_ctxt {
     fn cfg(&self) -> ast::CrateConfig;
-    fn parse_sess(&self) -> @parse::ParseSess;
+    fn parse_sess<'a>(&'a self) -> &'a parse::ParseSess;
     fn call_site(&self) -> Span;
     fn ident_of(&self, st: &str) -> ast::Ident;
 }
 
 #[cfg(test)]
-impl fake_ext_ctxt for @parse::ParseSess {
+impl fake_ext_ctxt for parse::ParseSess {
     fn cfg(&self) -> ast::CrateConfig {
         Vec::new()
     }
-    fn parse_sess(&self) -> @parse::ParseSess { *self }
+    fn parse_sess<'a>(&'a self) -> &'a parse::ParseSess { self }
     fn call_site(&self) -> Span {
         codemap::Span {
             lo: codemap::BytePos(0),
@@ -1470,7 +1470,7 @@ impl fake_ext_ctxt for @parse::ParseSess {
 }
 
 #[cfg(test)]
-fn mk_ctxt() -> @parse::ParseSess {
+fn mk_ctxt() -> parse::ParseSess {
     parse::new_parse_sess()
 }
 

src/librustdoc/html/highlight.rs

@@ -30,10 +30,10 @@ pub fn highlight(src: &str, class: Option<&str>) -> ~str {
     let sess = parse::new_parse_sess();
     let handler = diagnostic::default_handler();
     let span_handler = diagnostic::mk_span_handler(handler, sess.cm);
-    let fm = parse::string_to_filemap(sess, src.to_owned(), ~"<stdin>");
+    let fm = parse::string_to_filemap(&sess, src.to_owned(), ~"<stdin>");
 
     let mut out = io::MemWriter::new();
-    doit(sess,
+    doit(&sess,
          lexer::new_string_reader(span_handler, fm),
          class,
          &mut out).unwrap();
@@ -47,7 +47,7 @@ pub fn highlight(src: &str, class: Option<&str>) -> ~str {
 /// it's used. All source code emission is done as slices from the source map,
 /// not from the tokens themselves, in order to stay true to the original
 /// source.
-fn doit(sess: @parse::ParseSess, lexer: lexer::StringReader, class: Option<&str>,
+fn doit(sess: &parse::ParseSess, lexer: lexer::StringReader, class: Option<&str>,
         out: &mut Writer) -> io::IoResult<()> {
     use syntax::parse::lexer::Reader;
 

src/libsyntax/ext/base.rs

@@ -289,7 +289,7 @@ pub trait CrateLoader {
 // when a macro expansion occurs, the resulting nodes have the backtrace()
 // -> expn_info of their expansion context stored into their span.
 pub struct ExtCtxt<'a> {
-    parse_sess: @parse::ParseSess,
+    parse_sess: &'a parse::ParseSess,
     cfg: ast::CrateConfig,
     backtrace: Option<@ExpnInfo>,
     ecfg: expand::ExpansionConfig<'a>,
@@ -299,7 +299,7 @@ pub struct ExtCtxt<'a> {
 }
 
 impl<'a> ExtCtxt<'a> {
-    pub fn new<'a>(parse_sess: @parse::ParseSess, cfg: ast::CrateConfig,
+    pub fn new<'a>(parse_sess: &'a parse::ParseSess, cfg: ast::CrateConfig,
                    ecfg: expand::ExpansionConfig<'a>) -> ExtCtxt<'a> {
         ExtCtxt {
             parse_sess: parse_sess,
@@ -327,7 +327,7 @@ impl<'a> ExtCtxt<'a> {
     }
 
     pub fn codemap(&self) -> @CodeMap { self.parse_sess.cm }
-    pub fn parse_sess(&self) -> @parse::ParseSess { self.parse_sess }
+    pub fn parse_sess(&self) -> &'a parse::ParseSess { self.parse_sess }
     pub fn cfg(&self) -> ast::CrateConfig { self.cfg.clone() }
     pub fn call_site(&self) -> Span {
         match self.backtrace {

src/libsyntax/ext/expand.rs

@@ -838,12 +838,12 @@ pub fn new_span(cx: &ExtCtxt, sp: Span) -> Span {
     }
 }
 
-pub struct MacroExpander<'a> {
+pub struct MacroExpander<'a, 'b> {
     extsbox: SyntaxEnv,
-    cx: &'a mut ExtCtxt<'a>,
+    cx: &'a mut ExtCtxt<'b>,
 }
 
-impl<'a> Folder for MacroExpander<'a> {
+impl<'a, 'b> Folder for MacroExpander<'a, 'b> {
     fn fold_expr(&mut self, expr: @ast::Expr) -> @ast::Expr {
         expand_expr(expr, self)
     }
@@ -875,7 +875,7 @@ pub struct ExpansionConfig<'a> {
     crate_id: CrateId,
 }
 
-pub fn expand_crate(parse_sess: @parse::ParseSess,
+pub fn expand_crate(parse_sess: &parse::ParseSess,
                     cfg: ExpansionConfig,
                     c: Crate) -> Crate {
     let mut cx = ExtCtxt::new(parse_sess, c.config.clone(), cfg);
@@ -974,7 +974,7 @@ mod test {
     use ext::mtwt;
     use parse;
     use parse::token;
-    use util::parser_testing::{string_to_crate_and_sess};
+    use util::parser_testing::{string_to_parser};
     use util::parser_testing::{string_to_pat, strs_to_idents};
     use visit;
     use visit::Visitor;
@@ -1126,15 +1126,16 @@ mod test {
     //}
 
     fn expand_crate_str(crate_str: ~str) -> ast::Crate {
-        let (crate_ast,ps) = string_to_crate_and_sess(crate_str);
+        let ps = parse::new_parse_sess();
+        let crate_ast = string_to_parser(&ps, source_str).parse_crate_mod();
         // the cfg argument actually does matter, here...
         let mut loader = ErrLoader;
         let cfg = ::syntax::ext::expand::ExpansionConfig {
             loader: &mut loader,
             deriving_hash_type_parameter: false,
             crate_id: from_str("test").unwrap(),
         };
-        expand_crate(ps,cfg,crate_ast)
+        expand_crate(&ps,cfg,crate_ast)
     }
 
     //fn expand_and_resolve(crate_str: @str) -> ast::crate {

src/libsyntax/ext/format.rs

@@ -35,8 +35,8 @@ enum Position {
     Named(~str),
 }
 
-struct Context<'a> {
-    ecx: &'a mut ExtCtxt<'a>,
+struct Context<'a, 'b> {
+    ecx: &'a mut ExtCtxt<'b>,
     fmtsp: Span,
 
     // Parsed argument expressions and the types that we've found so far for
@@ -142,7 +142,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
     return (extra, Some((fmtstr, args, order, names)));
 }
 
-impl<'a> Context<'a> {
+impl<'a, 'b> Context<'a, 'b> {
     /// Verifies one piece of a parse string. All errors are not emitted as
     /// fatal so we can continue giving errors about this and possibly other
     /// format strings.

src/libsyntax/ext/tt/macro_parser.rs

@@ -170,9 +170,9 @@ pub enum NamedMatch {
     MatchedNonterminal(Nonterminal)
 }
 
-pub fn nameize(p_s: @ParseSess, ms: &[Matcher], res: &[@NamedMatch])
+pub fn nameize(p_s: &ParseSess, ms: &[Matcher], res: &[@NamedMatch])
             -> HashMap<Ident, @NamedMatch> {
-    fn n_rec(p_s: @ParseSess, m: &Matcher, res: &[@NamedMatch],
+    fn n_rec(p_s: &ParseSess, m: &Matcher, res: &[@NamedMatch],
              ret_val: &mut HashMap<Ident, @NamedMatch>) {
         match *m {
           codemap::Spanned {node: MatchTok(_), .. } => (),
@@ -205,7 +205,7 @@ pub enum ParseResult {
     Error(codemap::Span, ~str)
 }
 
-pub fn parse_or_else<R: Reader>(sess: @ParseSess,
+pub fn parse_or_else<R: Reader>(sess: &ParseSess,
                                 cfg: ast::CrateConfig,
                                 rdr: R,
                                 ms: Vec<Matcher> )
@@ -227,7 +227,7 @@ pub fn token_name_eq(t1 : &Token, t2 : &Token) -> bool {
     }
 }
 
-pub fn parse<R: Reader>(sess: @ParseSess,
+pub fn parse<R: Reader>(sess: &ParseSess,
                         cfg: ast::CrateConfig,
                         rdr: R,
                         ms: &[Matcher])

src/libsyntax/ext/tt/macro_rules.rs

@@ -30,11 +30,11 @@ use util::small_vector::SmallVector;
 use std::cell::RefCell;
 use std::vec_ng::Vec;
 
-struct ParserAnyMacro {
-    parser: RefCell<Parser>,
+struct ParserAnyMacro<'a> {
+    parser: RefCell<Parser<'a>>,
 }
 
-impl ParserAnyMacro {
+impl<'a> ParserAnyMacro<'a> {
     /// Make sure we don't have any tokens left to parse, so we don't
     /// silently drop anything. `allow_semi` is so that "optional"
     /// semilons at the end of normal expressions aren't complained
@@ -57,7 +57,7 @@ impl ParserAnyMacro {
     }
 }
 
-impl AnyMacro for ParserAnyMacro {
+impl<'a> AnyMacro for ParserAnyMacro<'a> {
     fn make_expr(&self) -> @ast::Expr {
         let ret = {
             let mut parser = self.parser.borrow_mut();

src/libsyntax/parse/attr.rs

@@ -28,7 +28,7 @@ pub trait ParserAttr {
     fn parse_optional_meta(&mut self) -> Vec<@ast::MetaItem> ;
 }
 
-impl ParserAttr for Parser {
+impl<'a> ParserAttr for Parser<'a> {
     // Parse attributes that appear before an item
     fn parse_outer_attributes(&mut self) -> Vec<ast::Attribute> {
         let mut attrs: Vec<ast::Attribute> = Vec::new();