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>()
}
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)
}
}
});
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)
});
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)>>,
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,
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()
#[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),
}
#[cfg(test)]
-fn mk_ctxt() -> @parse::ParseSess {
+fn mk_ctxt() -> parse::ParseSess {
parse::new_parse_sess()
}
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();
/// 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;
// 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>,
}
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,
}
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 {
}
}
-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)
}
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);
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;
//}
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 {
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 {
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
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.
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(_), .. } => (),
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> )
}
}
-pub fn parse<R: Reader>(sess: @ParseSess,
+pub fn parse<R: Reader>(sess: &ParseSess,
cfg: ast::CrateConfig,
rdr: R,
ms: &[Matcher])
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
}
}
-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();
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();
included_mod_stack: RefCell<Vec<Path> >,
}
-pub fn new_parse_sess() -> @ParseSess {
+pub fn new_parse_sess() -> ParseSess {
let cm = @CodeMap::new();
- @ParseSess {
+ ParseSess {
cm: cm,
span_diagnostic: mk_span_handler(default_handler(), cm),
included_mod_stack: RefCell::new(Vec::new()),
pub fn new_parse_sess_special_handler(sh: @SpanHandler,
cm: @codemap::CodeMap)
- -> @ParseSess {
- @ParseSess {
+ -> ParseSess {
+ ParseSess {
cm: cm,
span_diagnostic: sh,
included_mod_stack: RefCell::new(Vec::new()),
pub fn parse_crate_from_file(
input: &Path,
cfg: ast::CrateConfig,
- sess: @ParseSess
+ sess: &ParseSess
) -> ast::Crate {
new_parser_from_file(sess, cfg, input).parse_crate_mod()
// why is there no p.abort_if_errors here?
pub fn parse_crate_attrs_from_file(
input: &Path,
cfg: ast::CrateConfig,
- sess: @ParseSess
+ sess: &ParseSess
) -> Vec<ast::Attribute> {
let mut parser = new_parser_from_file(sess, cfg, input);
let (inner, _) = parser.parse_inner_attrs_and_next();
- return inner;
+ inner
}
pub fn parse_crate_from_source_str(name: ~str,
source: ~str,
cfg: ast::CrateConfig,
- sess: @ParseSess)
+ sess: &ParseSess)
-> ast::Crate {
let mut p = new_parser_from_source_str(sess,
cfg,
pub fn parse_crate_attrs_from_source_str(name: ~str,
source: ~str,
cfg: ast::CrateConfig,
- sess: @ParseSess)
+ sess: &ParseSess)
-> Vec<ast::Attribute> {
let mut p = new_parser_from_source_str(sess,
cfg,
name,
source);
let (inner, _) = maybe_aborted(p.parse_inner_attrs_and_next(),p);
- return inner;
+ inner
}
pub fn parse_expr_from_source_str(name: ~str,
source: ~str,
cfg: ast::CrateConfig,
- sess: @ParseSess)
+ 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)
+ sess: &ParseSess)
-> Option<@ast::Item> {
let mut p = new_parser_from_source_str(sess, cfg, name, source);
let attrs = p.parse_outer_attributes();
pub fn parse_meta_from_source_str(name: ~str,
source: ~str,
cfg: ast::CrateConfig,
- sess: @ParseSess)
+ sess: &ParseSess)
-> @ast::MetaItem {
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_meta_item(),p)
source: ~str,
cfg: ast::CrateConfig,
attrs: Vec<ast::Attribute> ,
- sess: @ParseSess)
+ sess: &ParseSess)
-> @ast::Stmt {
let mut p = new_parser_from_source_str(
sess,
pub fn parse_tts_from_source_str(name: ~str,
source: ~str,
cfg: ast::CrateConfig,
- sess: @ParseSess)
+ sess: &ParseSess)
-> Vec<ast::TokenTree> {
let mut p = new_parser_from_source_str(
sess,
}
// Create a new parser from a source string
-pub fn new_parser_from_source_str(sess: @ParseSess,
- cfg: ast::CrateConfig,
- name: ~str,
- source: ~str)
- -> Parser {
+pub fn new_parser_from_source_str<'a>(sess: &'a ParseSess,
+ cfg: ast::CrateConfig,
+ name: ~str,
+ source: ~str)
+ -> Parser<'a> {
filemap_to_parser(sess,string_to_filemap(sess,source,name),cfg)
}
/// Create a new parser, handling errors as appropriate
/// if the file doesn't exist
-pub fn new_parser_from_file(
- sess: @ParseSess,
+pub fn new_parser_from_file<'a>(
+ sess: &'a ParseSess,
cfg: ast::CrateConfig,
path: &Path
-) -> Parser {
+) -> Parser<'a> {
filemap_to_parser(sess,file_to_filemap(sess,path,None),cfg)
}
/// Given a session, a crate config, a path, and a span, add
/// the file at the given path to the codemap, and return a parser.
/// On an error, use the given span as the source of the problem.
-pub fn new_sub_parser_from_file(
- sess: @ParseSess,
+pub fn new_sub_parser_from_file<'a>(
+ sess: &'a ParseSess,
cfg: ast::CrateConfig,
path: &Path,
sp: Span
-) -> Parser {
+) -> Parser<'a> {
filemap_to_parser(sess,file_to_filemap(sess,path,Some(sp)),cfg)
}
/// Given a filemap and config, return a parser
-pub fn filemap_to_parser(sess: @ParseSess,
- filemap: @FileMap,
- cfg: ast::CrateConfig) -> Parser {
+pub fn filemap_to_parser<'a>(sess: &'a ParseSess,
+ filemap: @FileMap,
+ cfg: ast::CrateConfig) -> Parser<'a> {
tts_to_parser(sess,filemap_to_tts(sess,filemap),cfg)
}
// must preserve old name for now, because quote! from the *existing*
// compiler expands into it
-pub fn new_parser_from_tts(sess: @ParseSess,
- cfg: ast::CrateConfig,
- tts: Vec<ast::TokenTree> ) -> Parser {
+pub fn new_parser_from_tts<'a>(sess: &'a ParseSess,
+ cfg: ast::CrateConfig,
+ tts: Vec<ast::TokenTree>) -> Parser<'a> {
tts_to_parser(sess,tts,cfg)
}
/// Given a session and a path and an optional span (for error reporting),
/// add the path to the session's codemap and return the new filemap.
-pub fn file_to_filemap(sess: @ParseSess, path: &Path, spanopt: Option<Span>)
+pub fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
-> @FileMap {
let err = |msg: &str| {
match spanopt {
// 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)
}
// given a filemap, produce a sequence of token-trees
-pub fn filemap_to_tts(sess: @ParseSess, filemap: @FileMap)
+pub fn filemap_to_tts(sess: &ParseSess, filemap: @FileMap)
-> Vec<ast::TokenTree> {
// it appears to me that the cfg doesn't matter here... indeed,
// parsing tt's probably shouldn't require a parser at all.
}
// given tts and cfg, produce a parser
-pub fn tts_to_parser(sess: @ParseSess,
- tts: Vec<ast::TokenTree> ,
- cfg: ast::CrateConfig) -> Parser {
+pub fn tts_to_parser<'a>(sess: &'a ParseSess,
+ tts: Vec<ast::TokenTree>,
+ cfg: ast::CrateConfig) -> Parser<'a> {
let trdr = lexer::new_tt_reader(sess.span_diagnostic, None, tts);
Parser(sess, cfg, ~trdr)
}
}
#[test] fn parse_ident_pat () {
- let mut parser = string_to_parser(~"b");
+ let mut parser = string_to_parser(&new_parse_sess(), ~"b");
assert!(parser.parse_pat() ==
@ast::Pat{id: ast::DUMMY_NODE_ID,
node: ast::PatIdent(
fn eat_obsolete_ident(&mut self, ident: &str) -> bool;
}
-impl ParserObsoleteMethods for Parser {
+impl<'a> ParserObsoleteMethods for Parser<'a> {
/// Reports an obsolete syntax non-fatal error.
fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax) {
let (kind_str, desc) = match kind {
/* ident is handled by common.rs */
-pub fn Parser(sess: @ParseSess, cfg: ast::CrateConfig, rdr: ~Reader:)
- -> Parser {
+pub fn Parser<'a>(sess: &'a ParseSess, cfg: ast::CrateConfig, rdr: ~Reader:)
+ -> Parser<'a> {
let tok0 = rdr.next_token();
let span = tok0.sp;
let placeholder = TokenAndSpan {
}
}
-pub struct Parser {
- sess: @ParseSess,
+pub struct Parser<'a> {
+ sess: &'a ParseSess,
cfg: CrateConfig,
// the current token:
token: token::Token,
is_plain_ident(t) || *t == token::UNDERSCORE
}
-impl Parser {
+impl<'a> Parser<'a> {
// convert a token to a string using self's reader
pub fn token_to_str(token: &token::Token) -> ~str {
token::to_str(token)
use std::vec_ng::Vec;
-// map a string to tts, using a made-up filename: return both the TokenTree's
-// and the ParseSess
-pub fn string_to_tts_and_sess (source_str : ~str) -> (Vec<ast::TokenTree> , @ParseSess) {
- let ps = new_parse_sess();
- (filemap_to_tts(ps,string_to_filemap(ps,source_str,~"bogofile")),ps)
-}
-
// map a string to tts, using a made-up filename:
-pub fn string_to_tts(source_str : ~str) -> Vec<ast::TokenTree> {
- let (tts,_) = string_to_tts_and_sess(source_str);
- tts
-}
-
-pub fn string_to_parser_and_sess(source_str: ~str) -> (Parser,@ParseSess) {
+pub fn string_to_tts(source_str: ~str) -> Vec<ast::TokenTree> {
let ps = new_parse_sess();
- (new_parser_from_source_str(ps,Vec::new(),~"bogofile",source_str),ps)
+ filemap_to_tts(&ps, string_to_filemap(&ps, source_str,~"bogofile"))
}
// map string to parser (via tts)
-pub fn string_to_parser(source_str: ~str) -> Parser {
- let (p,_) = string_to_parser_and_sess(source_str);
- p
+pub fn string_to_parser<'a>(ps: &'a ParseSess, source_str: ~str) -> Parser<'a> {
+ new_parser_from_source_str(ps, Vec::new(), ~"bogofile", source_str)
}
fn with_error_checking_parse<T>(s: ~str, f: |&mut Parser| -> T) -> T {
- let mut p = string_to_parser(s);
+ let mut p = string_to_parser(&new_parse_sess(), s);
let x = f(&mut p);
p.abort_if_errors();
x
})
}
-// parse a string, return a crate and the ParseSess
-pub fn string_to_crate_and_sess (source_str : ~str) -> (ast::Crate,@ParseSess) {
- let (mut p,ps) = string_to_parser_and_sess(source_str);
- (p.parse_crate_mod(),ps)
-}
-
// parse a string, return an expr
pub fn string_to_expr (source_str : ~str) -> @ast::Expr {
with_error_checking_parse(source_str, |p| {
// parse a string, return a pat. Uses "irrefutable"... which doesn't
// (currently) affect parsing.
-pub fn string_to_pat(source_str : ~str) -> @ast::Pat {
- string_to_parser(source_str).parse_pat()
+pub fn string_to_pat(source_str: ~str) -> @ast::Pat {
+ string_to_parser(&new_parse_sess(), source_str).parse_pat()
}
// convert a vector of strings to a vector of ast::Ident's
projects / rust.git / commitdiff