1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
13 use ext::base::ExtCtxt;
15 use ext::build::AstBuilder;
20 /// Quasiquoting works via token trees.
22 /// This is registered as a set of expression syntax extension called quote!
23 /// that lifts its argument token-tree to an AST representing the
24 /// construction of the same token tree, with token::SubstNt interpreted
25 /// as antiquotes (splices).
30 use ext::base::ExtCtxt;
36 use ast::{TokenTree, Generics, Expr};
38 pub use parse::new_parser_from_tts;
39 pub use codemap::{BytePos, Span, dummy_spanned};
42 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> ;
45 impl ToTokens for TokenTree {
46 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
51 impl<T: ToTokens> ToTokens for Vec<T> {
52 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
53 self.iter().flat_map(|t| t.to_tokens(cx).into_iter()).collect()
57 impl<T: ToTokens> ToTokens for Spanned<T> {
58 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
59 // FIXME: use the span?
60 self.node.to_tokens(cx)
64 impl<T: ToTokens> ToTokens for Option<T> {
65 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
67 &Some(ref t) => t.to_tokens(cx),
73 /* Should be (when bugs in default methods are fixed):
75 trait ToSource : ToTokens {
76 // Takes a thing and generates a string containing rust code for it.
77 pub fn to_source() -> String;
79 // If you can make source, you can definitely make tokens.
80 pub fn to_tokens(cx: &ExtCtxt) -> ~[TokenTree] {
81 cx.parse_tts(self.to_source())
87 // FIXME: Move this trait to pprust and get rid of *_to_str?
89 // Takes a thing and generates a string containing rust code for it.
90 fn to_source(&self) -> String;
93 // FIXME (Issue #16472): This should go away after ToToken impls
94 // are revised to go directly to token-trees.
95 trait ToSourceWithHygiene : ToSource {
96 // Takes a thing and generates a string containing rust code
97 // for it, encoding Idents as special byte sequences to
98 // maintain hygiene across serialization and deserialization.
99 fn to_source_with_hygiene(&self) -> String;
102 macro_rules! impl_to_source {
103 (P<$t:ty>, $pp:ident) => (
104 impl ToSource for P<$t> {
105 fn to_source(&self) -> String {
109 impl ToSourceWithHygiene for P<$t> {
110 fn to_source_with_hygiene(&self) -> String {
111 pprust::with_hygiene::$pp(&**self)
115 ($t:ty, $pp:ident) => (
116 impl ToSource for $t {
117 fn to_source(&self) -> String {
121 impl ToSourceWithHygiene for $t {
122 fn to_source_with_hygiene(&self) -> String {
123 pprust::with_hygiene::$pp(self)
129 fn slice_to_source<'a, T: ToSource>(sep: &'static str, xs: &'a [T]) -> String {
131 .map(|i| i.to_source())
132 .collect::<Vec<String>>()
137 fn slice_to_source_with_hygiene<'a, T: ToSourceWithHygiene>(
138 sep: &'static str, xs: &'a [T]) -> String {
140 .map(|i| i.to_source_with_hygiene())
141 .collect::<Vec<String>>()
146 macro_rules! impl_to_source_slice {
147 ($t:ty, $sep:expr) => (
148 impl ToSource for [$t] {
149 fn to_source(&self) -> String {
150 slice_to_source($sep, self)
154 impl ToSourceWithHygiene for [$t] {
155 fn to_source_with_hygiene(&self) -> String {
156 slice_to_source_with_hygiene($sep, self)
162 impl ToSource for ast::Ident {
163 fn to_source(&self) -> String {
164 token::get_ident(*self).get().to_string()
168 impl ToSourceWithHygiene for ast::Ident {
169 fn to_source_with_hygiene(&self) -> String {
170 self.encode_with_hygiene()
174 impl_to_source! { ast::Ty, ty_to_string }
175 impl_to_source! { ast::Block, block_to_string }
176 impl_to_source! { ast::Arg, arg_to_string }
177 impl_to_source! { Generics, generics_to_string }
178 impl_to_source! { P<ast::Item>, item_to_string }
179 impl_to_source! { P<ast::Method>, method_to_string }
180 impl_to_source! { P<ast::Stmt>, stmt_to_string }
181 impl_to_source! { P<ast::Expr>, expr_to_string }
182 impl_to_source! { P<ast::Pat>, pat_to_string }
183 impl_to_source! { ast::Arm, arm_to_string }
184 impl_to_source_slice! { ast::Ty, ", " }
185 impl_to_source_slice! { P<ast::Item>, "\n\n" }
187 impl ToSource for ast::Attribute_ {
188 fn to_source(&self) -> String {
189 pprust::attribute_to_string(&dummy_spanned(self.clone()))
192 impl ToSourceWithHygiene for ast::Attribute_ {
193 fn to_source_with_hygiene(&self) -> String {
198 impl ToSource for str {
199 fn to_source(&self) -> String {
200 let lit = dummy_spanned(ast::LitStr(
201 token::intern_and_get_ident(self), ast::CookedStr));
202 pprust::lit_to_string(&lit)
205 impl ToSourceWithHygiene for str {
206 fn to_source_with_hygiene(&self) -> String {
211 impl ToSource for () {
212 fn to_source(&self) -> String {
216 impl ToSourceWithHygiene for () {
217 fn to_source_with_hygiene(&self) -> String {
222 impl ToSource for bool {
223 fn to_source(&self) -> String {
224 let lit = dummy_spanned(ast::LitBool(*self));
225 pprust::lit_to_string(&lit)
228 impl ToSourceWithHygiene for bool {
229 fn to_source_with_hygiene(&self) -> String {
234 impl ToSource for char {
235 fn to_source(&self) -> String {
236 let lit = dummy_spanned(ast::LitChar(*self));
237 pprust::lit_to_string(&lit)
240 impl ToSourceWithHygiene for char {
241 fn to_source_with_hygiene(&self) -> String {
246 macro_rules! impl_to_source_int {
247 (signed, $t:ty, $tag:expr) => (
248 impl ToSource for $t {
249 fn to_source(&self) -> String {
250 let lit = ast::LitInt(*self as u64, ast::SignedIntLit($tag,
251 ast::Sign::new(*self)));
252 pprust::lit_to_string(&dummy_spanned(lit))
255 impl ToSourceWithHygiene for $t {
256 fn to_source_with_hygiene(&self) -> String {
261 (unsigned, $t:ty, $tag:expr) => (
262 impl ToSource for $t {
263 fn to_source(&self) -> String {
264 let lit = ast::LitInt(*self as u64, ast::UnsignedIntLit($tag));
265 pprust::lit_to_string(&dummy_spanned(lit))
268 impl ToSourceWithHygiene for $t {
269 fn to_source_with_hygiene(&self) -> String {
276 impl_to_source_int! { signed, int, ast::TyIs(false) }
277 impl_to_source_int! { signed, i8, ast::TyI8 }
278 impl_to_source_int! { signed, i16, ast::TyI16 }
279 impl_to_source_int! { signed, i32, ast::TyI32 }
280 impl_to_source_int! { signed, i64, ast::TyI64 }
282 impl_to_source_int! { unsigned, uint, ast::TyUs(false) }
283 impl_to_source_int! { unsigned, u8, ast::TyU8 }
284 impl_to_source_int! { unsigned, u16, ast::TyU16 }
285 impl_to_source_int! { unsigned, u32, ast::TyU32 }
286 impl_to_source_int! { unsigned, u64, ast::TyU64 }
288 // Alas ... we write these out instead. All redundant.
290 macro_rules! impl_to_tokens {
292 impl ToTokens for $t {
293 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
294 cx.parse_tts_with_hygiene(self.to_source_with_hygiene())
300 macro_rules! impl_to_tokens_lifetime {
302 impl<'a> ToTokens for $t {
303 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
304 cx.parse_tts_with_hygiene(self.to_source_with_hygiene())
310 impl_to_tokens! { ast::Ident }
311 impl_to_tokens! { P<ast::Item> }
312 impl_to_tokens! { P<ast::Pat> }
313 impl_to_tokens! { ast::Arm }
314 impl_to_tokens! { P<ast::Method> }
315 impl_to_tokens_lifetime! { &'a [P<ast::Item>] }
316 impl_to_tokens! { ast::Ty }
317 impl_to_tokens_lifetime! { &'a [ast::Ty] }
318 impl_to_tokens! { Generics }
319 impl_to_tokens! { P<ast::Stmt> }
320 impl_to_tokens! { P<ast::Expr> }
321 impl_to_tokens! { ast::Block }
322 impl_to_tokens! { ast::Arg }
323 impl_to_tokens! { ast::Attribute_ }
324 impl_to_tokens_lifetime! { &'a str }
325 impl_to_tokens! { () }
326 impl_to_tokens! { char }
327 impl_to_tokens! { bool }
328 impl_to_tokens! { int }
329 impl_to_tokens! { i8 }
330 impl_to_tokens! { i16 }
331 impl_to_tokens! { i32 }
332 impl_to_tokens! { i64 }
333 impl_to_tokens! { uint }
334 impl_to_tokens! { u8 }
335 impl_to_tokens! { u16 }
336 impl_to_tokens! { u32 }
337 impl_to_tokens! { u64 }
339 pub trait ExtParseUtils {
340 fn parse_item(&self, s: String) -> P<ast::Item>;
341 fn parse_expr(&self, s: String) -> P<ast::Expr>;
342 fn parse_stmt(&self, s: String) -> P<ast::Stmt>;
343 fn parse_tts(&self, s: String) -> Vec<ast::TokenTree>;
346 trait ExtParseUtilsWithHygiene {
347 // FIXME (Issue #16472): This should go away after ToToken impls
348 // are revised to go directly to token-trees.
349 fn parse_tts_with_hygiene(&self, s: String) -> Vec<ast::TokenTree>;
352 impl<'a> ExtParseUtils for ExtCtxt<'a> {
354 fn parse_item(&self, s: String) -> P<ast::Item> {
355 parse::parse_item_from_source_str(
356 "<quote expansion>".to_string(),
359 self.parse_sess()).expect("parse error")
362 fn parse_stmt(&self, s: String) -> P<ast::Stmt> {
363 parse::parse_stmt_from_source_str("<quote expansion>".to_string(),
370 fn parse_expr(&self, s: String) -> P<ast::Expr> {
371 parse::parse_expr_from_source_str("<quote expansion>".to_string(),
377 fn parse_tts(&self, s: String) -> Vec<ast::TokenTree> {
378 parse::parse_tts_from_source_str("<quote expansion>".to_string(),
385 impl<'a> ExtParseUtilsWithHygiene for ExtCtxt<'a> {
387 fn parse_tts_with_hygiene(&self, s: String) -> Vec<ast::TokenTree> {
388 use parse::with_hygiene::parse_tts_from_source_str;
389 parse_tts_from_source_str("<quote expansion>".to_string(),
399 pub fn expand_quote_tokens<'cx>(cx: &'cx mut ExtCtxt,
401 tts: &[ast::TokenTree])
402 -> Box<base::MacResult+'cx> {
403 let (cx_expr, expr) = expand_tts(cx, sp, tts);
404 let expanded = expand_wrapper(cx, sp, cx_expr, expr);
405 base::MacExpr::new(expanded)
408 pub fn expand_quote_expr<'cx>(cx: &'cx mut ExtCtxt,
410 tts: &[ast::TokenTree])
411 -> Box<base::MacResult+'cx> {
412 let expanded = expand_parse_call(cx, sp, "parse_expr", Vec::new(), tts);
413 base::MacExpr::new(expanded)
416 pub fn expand_quote_item<'cx>(cx: &mut ExtCtxt,
418 tts: &[ast::TokenTree])
419 -> Box<base::MacResult+'cx> {
420 let expanded = expand_parse_call(cx, sp, "parse_item_with_outer_attributes",
422 base::MacExpr::new(expanded)
425 pub fn expand_quote_pat<'cx>(cx: &'cx mut ExtCtxt,
427 tts: &[ast::TokenTree])
428 -> Box<base::MacResult+'cx> {
429 let expanded = expand_parse_call(cx, sp, "parse_pat", vec!(), tts);
430 base::MacExpr::new(expanded)
433 pub fn expand_quote_arm(cx: &mut ExtCtxt,
435 tts: &[ast::TokenTree])
436 -> Box<base::MacResult+'static> {
437 let expanded = expand_parse_call(cx, sp, "parse_arm", vec!(), tts);
438 base::MacExpr::new(expanded)
441 pub fn expand_quote_ty(cx: &mut ExtCtxt,
443 tts: &[ast::TokenTree])
444 -> Box<base::MacResult+'static> {
445 let expanded = expand_parse_call(cx, sp, "parse_ty", vec!(), tts);
446 base::MacExpr::new(expanded)
449 pub fn expand_quote_method(cx: &mut ExtCtxt,
451 tts: &[ast::TokenTree])
452 -> Box<base::MacResult+'static> {
453 let expanded = expand_parse_call(cx, sp, "parse_method_with_outer_attributes",
455 base::MacExpr::new(expanded)
458 pub fn expand_quote_stmt(cx: &mut ExtCtxt,
460 tts: &[ast::TokenTree])
461 -> Box<base::MacResult+'static> {
462 let e_attrs = cx.expr_vec_ng(sp);
463 let expanded = expand_parse_call(cx, sp, "parse_stmt",
465 base::MacExpr::new(expanded)
468 fn ids_ext(strs: Vec<String> ) -> Vec<ast::Ident> {
469 strs.iter().map(|str| str_to_ident(&(*str)[])).collect()
472 fn id_ext(str: &str) -> ast::Ident {
476 // Lift an ident to the expr that evaluates to that ident.
477 fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
478 let e_str = cx.expr_str(sp, token::get_ident(ident));
479 cx.expr_method_call(sp,
480 cx.expr_ident(sp, id_ext("ext_cx")),
485 // Lift a name to the expr that evaluates to that name
486 fn mk_name(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
487 let e_str = cx.expr_str(sp, token::get_ident(ident));
488 cx.expr_method_call(sp,
489 cx.expr_ident(sp, id_ext("ext_cx")),
494 fn mk_ast_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
495 let idents = vec!(id_ext("syntax"), id_ext("ast"), id_ext(name));
496 cx.expr_path(cx.path_global(sp, idents))
499 fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
500 let idents = vec!(id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name));
501 cx.expr_path(cx.path_global(sp, idents))
504 fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOpToken) -> P<ast::Expr> {
505 let name = match bop {
506 token::Plus => "Plus",
507 token::Minus => "Minus",
508 token::Star => "Star",
509 token::Slash => "Slash",
510 token::Percent => "Percent",
511 token::Caret => "Caret",
517 mk_token_path(cx, sp, name)
520 fn mk_delim(cx: &ExtCtxt, sp: Span, delim: token::DelimToken) -> P<ast::Expr> {
521 let name = match delim {
522 token::Paren => "Paren",
523 token::Bracket => "Bracket",
524 token::Brace => "Brace",
526 mk_token_path(cx, sp, name)
529 #[allow(non_upper_case_globals)]
530 fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> {
531 macro_rules! mk_lit {
532 ($name: expr, $suffix: expr, $($args: expr),*) => {{
533 let inner = cx.expr_call(sp, mk_token_path(cx, sp, $name), vec![$($args),*]);
534 let suffix = match $suffix {
535 Some(name) => cx.expr_some(sp, mk_name(cx, sp, ast::Ident::new(name))),
536 None => cx.expr_none(sp)
538 cx.expr_call(sp, mk_token_path(cx, sp, "Literal"), vec![inner, suffix])
542 token::BinOp(binop) => {
543 return cx.expr_call(sp, mk_token_path(cx, sp, "BinOp"), vec!(mk_binop(cx, sp, binop)));
545 token::BinOpEq(binop) => {
546 return cx.expr_call(sp, mk_token_path(cx, sp, "BinOpEq"),
547 vec!(mk_binop(cx, sp, binop)));
550 token::OpenDelim(delim) => {
551 return cx.expr_call(sp, mk_token_path(cx, sp, "OpenDelim"),
552 vec![mk_delim(cx, sp, delim)]);
554 token::CloseDelim(delim) => {
555 return cx.expr_call(sp, mk_token_path(cx, sp, "CloseDelim"),
556 vec![mk_delim(cx, sp, delim)]);
559 token::Literal(token::Byte(i), suf) => {
560 let e_byte = mk_name(cx, sp, i.ident());
561 return mk_lit!("Byte", suf, e_byte);
564 token::Literal(token::Char(i), suf) => {
565 let e_char = mk_name(cx, sp, i.ident());
566 return mk_lit!("Char", suf, e_char);
569 token::Literal(token::Integer(i), suf) => {
570 let e_int = mk_name(cx, sp, i.ident());
571 return mk_lit!("Integer", suf, e_int);
574 token::Literal(token::Float(fident), suf) => {
575 let e_fident = mk_name(cx, sp, fident.ident());
576 return mk_lit!("Float", suf, e_fident);
579 token::Literal(token::Str_(ident), suf) => {
580 return mk_lit!("Str_", suf, mk_name(cx, sp, ident.ident()))
583 token::Literal(token::StrRaw(ident, n), suf) => {
584 return mk_lit!("StrRaw", suf, mk_name(cx, sp, ident.ident()), cx.expr_uint(sp, n))
587 token::Ident(ident, style) => {
588 return cx.expr_call(sp,
589 mk_token_path(cx, sp, "Ident"),
590 vec![mk_ident(cx, sp, ident),
592 ModName => mk_token_path(cx, sp, "ModName"),
593 Plain => mk_token_path(cx, sp, "Plain"),
597 token::Lifetime(ident) => {
598 return cx.expr_call(sp,
599 mk_token_path(cx, sp, "Lifetime"),
600 vec!(mk_ident(cx, sp, ident)));
603 token::DocComment(ident) => {
604 return cx.expr_call(sp,
605 mk_token_path(cx, sp, "DocComment"),
606 vec!(mk_name(cx, sp, ident.ident())));
609 token::Interpolated(_) => panic!("quote! with interpolated token"),
614 let name = match *tok {
618 token::EqEq => "EqEq",
622 token::AndAnd => "AndAnd",
623 token::OrOr => "OrOr",
625 token::Tilde => "Tilde",
628 token::DotDot => "DotDot",
629 token::Comma => "Comma",
630 token::Semi => "Semi",
631 token::Colon => "Colon",
632 token::ModSep => "ModSep",
633 token::RArrow => "RArrow",
634 token::LArrow => "LArrow",
635 token::FatArrow => "FatArrow",
636 token::Pound => "Pound",
637 token::Dollar => "Dollar",
638 token::Underscore => "Underscore",
642 mk_token_path(cx, sp, name)
645 fn mk_tt(cx: &ExtCtxt, tt: &ast::TokenTree) -> Vec<P<ast::Stmt>> {
647 ast::TtToken(sp, SubstNt(ident, _)) => {
648 // tt.extend($ident.to_tokens(ext_cx).into_iter())
651 cx.expr_method_call(sp,
652 cx.expr_ident(sp, ident),
654 vec!(cx.expr_ident(sp, id_ext("ext_cx"))));
656 cx.expr_method_call(sp, e_to_toks, id_ext("into_iter"), vec![]);
659 cx.expr_method_call(sp,
660 cx.expr_ident(sp, id_ext("tt")),
664 vec!(cx.stmt_expr(e_push))
666 ref tt @ ast::TtToken(_, MatchNt(..)) => {
667 let mut seq = vec![];
668 for i in range(0, tt.len()) {
669 seq.push(tt.get_tt(i));
673 ast::TtToken(sp, ref tok) => {
674 let e_sp = cx.expr_ident(sp, id_ext("_sp"));
675 let e_tok = cx.expr_call(sp,
676 mk_ast_path(cx, sp, "TtToken"),
677 vec!(e_sp, mk_token(cx, sp, tok)));
679 cx.expr_method_call(sp,
680 cx.expr_ident(sp, id_ext("tt")),
683 vec!(cx.stmt_expr(e_push))
685 ast::TtDelimited(_, ref delimed) => {
686 mk_tt(cx, &delimed.open_tt()).into_iter()
687 .chain(delimed.tts.iter().flat_map(|tt| mk_tt(cx, tt).into_iter()))
688 .chain(mk_tt(cx, &delimed.close_tt()).into_iter())
691 ast::TtSequence(..) => panic!("TtSequence in quote!"),
695 fn mk_tts(cx: &ExtCtxt, tts: &[ast::TokenTree]) -> Vec<P<ast::Stmt>> {
696 let mut ss = Vec::new();
697 for tt in tts.iter() {
698 ss.extend(mk_tt(cx, tt).into_iter());
703 fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
704 -> (P<ast::Expr>, P<ast::Expr>) {
705 // NB: It appears that the main parser loses its mind if we consider
706 // $foo as a TtNonterminal during the main parse, so we have to re-parse
707 // under quote_depth > 0. This is silly and should go away; the _guess_ is
708 // it has to do with transition away from supporting old-style macros, so
709 // try removing it when enough of them are gone.
711 let mut p = cx.new_parser_from_tts(tts);
714 let cx_expr = p.parse_expr();
715 if !p.eat(&token::Comma) {
716 p.fatal("expected token `,`");
719 let tts = p.parse_all_token_trees();
722 // We also bind a single value, sp, to ext_cx.call_site()
724 // This causes every span in a token-tree quote to be attributed to the
725 // call site of the extension using the quote. We can't really do much
726 // better since the source of the quote may well be in a library that
727 // was not even parsed by this compilation run, that the user has no
728 // source code for (eg. in libsyntax, which they're just _using_).
730 // The old quasiquoter had an elaborate mechanism for denoting input
731 // file locations from which quotes originated; unfortunately this
732 // relied on feeding the source string of the quote back into the
733 // compiler (which we don't really want to do) and, in any case, only
734 // pushed the problem a very small step further back: an error
735 // resulting from a parse of the resulting quote is still attributed to
736 // the site the string literal occurred, which was in a source file
737 // _other_ than the one the user has control over. For example, an
738 // error in a quote from the protocol compiler, invoked in user code
739 // using macro_rules! for example, will be attributed to the macro_rules.rs
740 // file in libsyntax, which the user might not even have source to (unless
741 // they happen to have a compiler on hand). Over all, the phase distinction
742 // just makes quotes "hard to attribute". Possibly this could be fixed
743 // by recreating some of the original qq machinery in the tt regime
744 // (pushing fake FileMaps onto the parser to account for original sites
745 // of quotes, for example) but at this point it seems not likely to be
748 let e_sp = cx.expr_method_call(sp,
749 cx.expr_ident(sp, id_ext("ext_cx")),
753 let stmt_let_sp = cx.stmt_let(sp, false,
757 let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp));
759 let mut vector = vec!(stmt_let_sp, stmt_let_tt);
760 vector.extend(mk_tts(cx, &tts[]).into_iter());
761 let block = cx.expr_block(
764 Some(cx.expr_ident(sp, id_ext("tt")))));
769 fn expand_wrapper(cx: &ExtCtxt,
771 cx_expr: P<ast::Expr>,
772 expr: P<ast::Expr>) -> P<ast::Expr> {
773 // Explicitly borrow to avoid moving from the invoker (#16992)
774 let cx_expr_borrow = cx.expr_addr_of(sp, cx.expr_deref(sp, cx_expr));
775 let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr_borrow);
778 &["syntax", "ext", "quote", "rt"],
779 ].iter().map(|path| {
780 let path = path.iter().map(|s| s.to_string()).collect();
781 cx.stmt_item(sp, cx.item_use_glob(sp, ast::Inherited, ids_ext(path)))
782 }).chain(Some(stmt_let_ext_cx).into_iter()).collect();
784 cx.expr_block(cx.block_all(sp, stmts, Some(expr)))
787 fn expand_parse_call(cx: &ExtCtxt,
790 arg_exprs: Vec<P<ast::Expr>> ,
791 tts: &[ast::TokenTree]) -> P<ast::Expr> {
792 let (cx_expr, tts_expr) = expand_tts(cx, sp, tts);
794 let cfg_call = |&:| cx.expr_method_call(
795 sp, cx.expr_ident(sp, id_ext("ext_cx")),
796 id_ext("cfg"), Vec::new());
798 let parse_sess_call = |&:| cx.expr_method_call(
799 sp, cx.expr_ident(sp, id_ext("ext_cx")),
800 id_ext("parse_sess"), Vec::new());
802 let new_parser_call =
804 cx.expr_ident(sp, id_ext("new_parser_from_tts")),
805 vec!(parse_sess_call(), cfg_call(), tts_expr));
807 let expr = cx.expr_method_call(sp, new_parser_call, id_ext(parse_method),
810 expand_wrapper(cx, sp, cx_expr, expr)