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 let res = parse::parse_item_from_source_str(
356 "<quote expansion>".to_string(),
363 error!("parse error");
369 fn parse_stmt(&self, s: String) -> P<ast::Stmt> {
370 parse::parse_stmt_from_source_str("<quote expansion>".to_string(),
377 fn parse_expr(&self, s: String) -> P<ast::Expr> {
378 parse::parse_expr_from_source_str("<quote expansion>".to_string(),
384 fn parse_tts(&self, s: String) -> Vec<ast::TokenTree> {
385 parse::parse_tts_from_source_str("<quote expansion>".to_string(),
392 impl<'a> ExtParseUtilsWithHygiene for ExtCtxt<'a> {
394 fn parse_tts_with_hygiene(&self, s: String) -> Vec<ast::TokenTree> {
395 use parse::with_hygiene::parse_tts_from_source_str;
396 parse_tts_from_source_str("<quote expansion>".to_string(),
406 pub fn expand_quote_tokens<'cx>(cx: &'cx mut ExtCtxt,
408 tts: &[ast::TokenTree])
409 -> Box<base::MacResult+'cx> {
410 let (cx_expr, expr) = expand_tts(cx, sp, tts);
411 let expanded = expand_wrapper(cx, sp, cx_expr, expr);
412 base::MacExpr::new(expanded)
415 pub fn expand_quote_expr<'cx>(cx: &'cx mut ExtCtxt,
417 tts: &[ast::TokenTree])
418 -> Box<base::MacResult+'cx> {
419 let expanded = expand_parse_call(cx, sp, "parse_expr", Vec::new(), tts);
420 base::MacExpr::new(expanded)
423 pub fn expand_quote_item<'cx>(cx: &mut ExtCtxt,
425 tts: &[ast::TokenTree])
426 -> Box<base::MacResult+'cx> {
427 let expanded = expand_parse_call(cx, sp, "parse_item_with_outer_attributes",
429 base::MacExpr::new(expanded)
432 pub fn expand_quote_pat<'cx>(cx: &'cx mut ExtCtxt,
434 tts: &[ast::TokenTree])
435 -> Box<base::MacResult+'cx> {
436 let expanded = expand_parse_call(cx, sp, "parse_pat", vec!(), tts);
437 base::MacExpr::new(expanded)
440 pub fn expand_quote_arm(cx: &mut ExtCtxt,
442 tts: &[ast::TokenTree])
443 -> Box<base::MacResult+'static> {
444 let expanded = expand_parse_call(cx, sp, "parse_arm", vec!(), tts);
445 base::MacExpr::new(expanded)
448 pub fn expand_quote_ty(cx: &mut ExtCtxt,
450 tts: &[ast::TokenTree])
451 -> Box<base::MacResult+'static> {
452 let expanded = expand_parse_call(cx, sp, "parse_ty", vec!(), tts);
453 base::MacExpr::new(expanded)
456 pub fn expand_quote_method(cx: &mut ExtCtxt,
458 tts: &[ast::TokenTree])
459 -> Box<base::MacResult+'static> {
460 let expanded = expand_parse_call(cx, sp, "parse_method_with_outer_attributes",
462 base::MacExpr::new(expanded)
465 pub fn expand_quote_stmt(cx: &mut ExtCtxt,
467 tts: &[ast::TokenTree])
468 -> Box<base::MacResult+'static> {
469 let e_attrs = cx.expr_vec_ng(sp);
470 let expanded = expand_parse_call(cx, sp, "parse_stmt",
472 base::MacExpr::new(expanded)
475 fn ids_ext(strs: Vec<String> ) -> Vec<ast::Ident> {
476 strs.iter().map(|str| str_to_ident(&(*str)[])).collect()
479 fn id_ext(str: &str) -> ast::Ident {
483 // Lift an ident to the expr that evaluates to that ident.
484 fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
485 let e_str = cx.expr_str(sp, token::get_ident(ident));
486 cx.expr_method_call(sp,
487 cx.expr_ident(sp, id_ext("ext_cx")),
492 // Lift a name to the expr that evaluates to that name
493 fn mk_name(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
494 let e_str = cx.expr_str(sp, token::get_ident(ident));
495 cx.expr_method_call(sp,
496 cx.expr_ident(sp, id_ext("ext_cx")),
501 fn mk_ast_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
502 let idents = vec!(id_ext("syntax"), id_ext("ast"), id_ext(name));
503 cx.expr_path(cx.path_global(sp, idents))
506 fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
507 let idents = vec!(id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name));
508 cx.expr_path(cx.path_global(sp, idents))
511 fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOpToken) -> P<ast::Expr> {
512 let name = match bop {
513 token::Plus => "Plus",
514 token::Minus => "Minus",
515 token::Star => "Star",
516 token::Slash => "Slash",
517 token::Percent => "Percent",
518 token::Caret => "Caret",
524 mk_token_path(cx, sp, name)
527 fn mk_delim(cx: &ExtCtxt, sp: Span, delim: token::DelimToken) -> P<ast::Expr> {
528 let name = match delim {
529 token::Paren => "Paren",
530 token::Bracket => "Bracket",
531 token::Brace => "Brace",
533 mk_token_path(cx, sp, name)
536 #[allow(non_upper_case_globals)]
537 fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> {
538 macro_rules! mk_lit {
539 ($name: expr, $suffix: expr, $($args: expr),*) => {{
540 let inner = cx.expr_call(sp, mk_token_path(cx, sp, $name), vec![$($args),*]);
541 let suffix = match $suffix {
542 Some(name) => cx.expr_some(sp, mk_name(cx, sp, ast::Ident::new(name))),
543 None => cx.expr_none(sp)
545 cx.expr_call(sp, mk_token_path(cx, sp, "Literal"), vec![inner, suffix])
549 token::BinOp(binop) => {
550 return cx.expr_call(sp, mk_token_path(cx, sp, "BinOp"), vec!(mk_binop(cx, sp, binop)));
552 token::BinOpEq(binop) => {
553 return cx.expr_call(sp, mk_token_path(cx, sp, "BinOpEq"),
554 vec!(mk_binop(cx, sp, binop)));
557 token::OpenDelim(delim) => {
558 return cx.expr_call(sp, mk_token_path(cx, sp, "OpenDelim"),
559 vec![mk_delim(cx, sp, delim)]);
561 token::CloseDelim(delim) => {
562 return cx.expr_call(sp, mk_token_path(cx, sp, "CloseDelim"),
563 vec![mk_delim(cx, sp, delim)]);
566 token::Literal(token::Byte(i), suf) => {
567 let e_byte = mk_name(cx, sp, i.ident());
568 return mk_lit!("Byte", suf, e_byte);
571 token::Literal(token::Char(i), suf) => {
572 let e_char = mk_name(cx, sp, i.ident());
573 return mk_lit!("Char", suf, e_char);
576 token::Literal(token::Integer(i), suf) => {
577 let e_int = mk_name(cx, sp, i.ident());
578 return mk_lit!("Integer", suf, e_int);
581 token::Literal(token::Float(fident), suf) => {
582 let e_fident = mk_name(cx, sp, fident.ident());
583 return mk_lit!("Float", suf, e_fident);
586 token::Literal(token::Str_(ident), suf) => {
587 return mk_lit!("Str_", suf, mk_name(cx, sp, ident.ident()))
590 token::Literal(token::StrRaw(ident, n), suf) => {
591 return mk_lit!("StrRaw", suf, mk_name(cx, sp, ident.ident()), cx.expr_uint(sp, n))
594 token::Ident(ident, style) => {
595 return cx.expr_call(sp,
596 mk_token_path(cx, sp, "Ident"),
597 vec![mk_ident(cx, sp, ident),
599 ModName => mk_token_path(cx, sp, "ModName"),
600 Plain => mk_token_path(cx, sp, "Plain"),
604 token::Lifetime(ident) => {
605 return cx.expr_call(sp,
606 mk_token_path(cx, sp, "Lifetime"),
607 vec!(mk_ident(cx, sp, ident)));
610 token::DocComment(ident) => {
611 return cx.expr_call(sp,
612 mk_token_path(cx, sp, "DocComment"),
613 vec!(mk_name(cx, sp, ident.ident())));
616 token::Interpolated(_) => panic!("quote! with interpolated token"),
621 let name = match *tok {
625 token::EqEq => "EqEq",
629 token::AndAnd => "AndAnd",
630 token::OrOr => "OrOr",
632 token::Tilde => "Tilde",
635 token::DotDot => "DotDot",
636 token::Comma => "Comma",
637 token::Semi => "Semi",
638 token::Colon => "Colon",
639 token::ModSep => "ModSep",
640 token::RArrow => "RArrow",
641 token::LArrow => "LArrow",
642 token::FatArrow => "FatArrow",
643 token::Pound => "Pound",
644 token::Dollar => "Dollar",
645 token::Underscore => "Underscore",
649 mk_token_path(cx, sp, name)
652 fn mk_tt(cx: &ExtCtxt, tt: &ast::TokenTree) -> Vec<P<ast::Stmt>> {
654 ast::TtToken(sp, SubstNt(ident, _)) => {
655 // tt.extend($ident.to_tokens(ext_cx).into_iter())
658 cx.expr_method_call(sp,
659 cx.expr_ident(sp, ident),
661 vec!(cx.expr_ident(sp, id_ext("ext_cx"))));
663 cx.expr_method_call(sp, e_to_toks, id_ext("into_iter"), vec![]);
666 cx.expr_method_call(sp,
667 cx.expr_ident(sp, id_ext("tt")),
671 vec!(cx.stmt_expr(e_push))
673 ref tt @ ast::TtToken(_, MatchNt(..)) => {
674 let mut seq = vec![];
675 for i in range(0, tt.len()) {
676 seq.push(tt.get_tt(i));
680 ast::TtToken(sp, ref tok) => {
681 let e_sp = cx.expr_ident(sp, id_ext("_sp"));
682 let e_tok = cx.expr_call(sp,
683 mk_ast_path(cx, sp, "TtToken"),
684 vec!(e_sp, mk_token(cx, sp, tok)));
686 cx.expr_method_call(sp,
687 cx.expr_ident(sp, id_ext("tt")),
690 vec!(cx.stmt_expr(e_push))
692 ast::TtDelimited(_, ref delimed) => {
693 mk_tt(cx, &delimed.open_tt()).into_iter()
694 .chain(delimed.tts.iter().flat_map(|tt| mk_tt(cx, tt).into_iter()))
695 .chain(mk_tt(cx, &delimed.close_tt()).into_iter())
698 ast::TtSequence(..) => panic!("TtSequence in quote!"),
702 fn mk_tts(cx: &ExtCtxt, tts: &[ast::TokenTree]) -> Vec<P<ast::Stmt>> {
703 let mut ss = Vec::new();
704 for tt in tts.iter() {
705 ss.extend(mk_tt(cx, tt).into_iter());
710 fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
711 -> (P<ast::Expr>, P<ast::Expr>) {
712 // NB: It appears that the main parser loses its mind if we consider
713 // $foo as a TtNonterminal during the main parse, so we have to re-parse
714 // under quote_depth > 0. This is silly and should go away; the _guess_ is
715 // it has to do with transition away from supporting old-style macros, so
716 // try removing it when enough of them are gone.
718 let mut p = cx.new_parser_from_tts(tts);
721 let cx_expr = p.parse_expr();
722 if !p.eat(&token::Comma) {
723 p.fatal("expected token `,`");
726 let tts = p.parse_all_token_trees();
729 // We also bind a single value, sp, to ext_cx.call_site()
731 // This causes every span in a token-tree quote to be attributed to the
732 // call site of the extension using the quote. We can't really do much
733 // better since the source of the quote may well be in a library that
734 // was not even parsed by this compilation run, that the user has no
735 // source code for (eg. in libsyntax, which they're just _using_).
737 // The old quasiquoter had an elaborate mechanism for denoting input
738 // file locations from which quotes originated; unfortunately this
739 // relied on feeding the source string of the quote back into the
740 // compiler (which we don't really want to do) and, in any case, only
741 // pushed the problem a very small step further back: an error
742 // resulting from a parse of the resulting quote is still attributed to
743 // the site the string literal occurred, which was in a source file
744 // _other_ than the one the user has control over. For example, an
745 // error in a quote from the protocol compiler, invoked in user code
746 // using macro_rules! for example, will be attributed to the macro_rules.rs
747 // file in libsyntax, which the user might not even have source to (unless
748 // they happen to have a compiler on hand). Over all, the phase distinction
749 // just makes quotes "hard to attribute". Possibly this could be fixed
750 // by recreating some of the original qq machinery in the tt regime
751 // (pushing fake FileMaps onto the parser to account for original sites
752 // of quotes, for example) but at this point it seems not likely to be
755 let e_sp = cx.expr_method_call(sp,
756 cx.expr_ident(sp, id_ext("ext_cx")),
760 let stmt_let_sp = cx.stmt_let(sp, false,
764 let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp));
766 let mut vector = vec!(stmt_let_sp, stmt_let_tt);
767 vector.extend(mk_tts(cx, &tts[]).into_iter());
768 let block = cx.expr_block(
772 Some(cx.expr_ident(sp, id_ext("tt")))));
777 fn expand_wrapper(cx: &ExtCtxt,
779 cx_expr: P<ast::Expr>,
780 expr: P<ast::Expr>) -> P<ast::Expr> {
782 &["syntax", "ext", "quote", "rt"],
783 ].iter().map(|path| {
784 let path = path.iter().map(|s| s.to_string()).collect();
785 cx.view_use_glob(sp, ast::Inherited, ids_ext(path))
788 // Explicitly borrow to avoid moving from the invoker (#16992)
789 let cx_expr_borrow = cx.expr_addr_of(sp, cx.expr_deref(sp, cx_expr));
790 let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr_borrow);
792 cx.expr_block(cx.block_all(sp, uses, vec!(stmt_let_ext_cx), Some(expr)))
795 fn expand_parse_call(cx: &ExtCtxt,
798 arg_exprs: Vec<P<ast::Expr>> ,
799 tts: &[ast::TokenTree]) -> P<ast::Expr> {
800 let (cx_expr, tts_expr) = expand_tts(cx, sp, tts);
802 let cfg_call = |&:| cx.expr_method_call(
803 sp, cx.expr_ident(sp, id_ext("ext_cx")),
804 id_ext("cfg"), Vec::new());
806 let parse_sess_call = |&:| cx.expr_method_call(
807 sp, cx.expr_ident(sp, id_ext("ext_cx")),
808 id_ext("parse_sess"), Vec::new());
810 let new_parser_call =
812 cx.expr_ident(sp, id_ext("new_parser_from_tts")),
813 vec!(parse_sess_call(), cfg_call(), tts_expr));
815 let expr = cx.expr_method_call(sp, new_parser_call, id_ext(parse_method),
818 expand_wrapper(cx, sp, cx_expr, expr)