1 // Copyright 2015 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.
11 use ast::{self, Arg, Arm, Block, Expr, Item, Pat, Stmt, Ty};
13 use ext::base::ExtCtxt;
15 use ext::build::AstBuilder;
16 use parse::parser::{Parser, PathStyle};
19 use tokenstream::{TokenStream, TokenTree};
22 /// Quasiquoting works via token trees.
24 /// This is registered as a set of expression syntax extension called quote!
25 /// that lifts its argument token-tree to an AST representing the
26 /// construction of the same token tree, with `token::SubstNt` interpreted
27 /// as antiquotes (splices).
32 use ext::base::ExtCtxt;
33 use parse::{self, classify};
34 use parse::token::{self, Token};
38 use tokenstream::{self, TokenTree, TokenStream};
40 pub use parse::new_parser_from_tts;
41 pub use syntax_pos::{BytePos, Span, DUMMY_SP};
42 pub use codemap::{dummy_spanned};
45 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree>;
48 impl ToTokens for TokenTree {
49 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
54 impl<T: ToTokens> ToTokens for Vec<T> {
55 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
56 self.iter().flat_map(|t| t.to_tokens(cx)).collect()
60 impl<T: ToTokens> ToTokens for Spanned<T> {
61 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
62 // FIXME: use the span?
63 self.node.to_tokens(cx)
67 impl<T: ToTokens> ToTokens for Option<T> {
68 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
70 Some(ref t) => t.to_tokens(cx),
76 impl ToTokens for ast::Ident {
77 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
78 vec![TokenTree::Token(DUMMY_SP, token::Ident(*self))]
82 impl ToTokens for ast::Path {
83 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
84 let nt = token::NtPath(self.clone());
85 vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
89 impl ToTokens for ast::Ty {
90 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
91 let nt = token::NtTy(P(self.clone()));
92 vec![TokenTree::Token(self.span, Token::interpolated(nt))]
96 impl ToTokens for ast::Block {
97 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
98 let nt = token::NtBlock(P(self.clone()));
99 vec![TokenTree::Token(self.span, Token::interpolated(nt))]
103 impl ToTokens for ast::Generics {
104 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
105 let nt = token::NtGenerics(self.clone());
106 vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
110 impl ToTokens for ast::WhereClause {
111 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
112 let nt = token::NtWhereClause(self.clone());
113 vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
117 impl ToTokens for P<ast::Item> {
118 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
119 let nt = token::NtItem(self.clone());
120 vec![TokenTree::Token(self.span, Token::interpolated(nt))]
124 impl ToTokens for ast::ImplItem {
125 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
126 let nt = token::NtImplItem(self.clone());
127 vec![TokenTree::Token(self.span, Token::interpolated(nt))]
131 impl ToTokens for P<ast::ImplItem> {
132 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
133 let nt = token::NtImplItem((**self).clone());
134 vec![TokenTree::Token(self.span, Token::interpolated(nt))]
138 impl ToTokens for ast::TraitItem {
139 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
140 let nt = token::NtTraitItem(self.clone());
141 vec![TokenTree::Token(self.span, Token::interpolated(nt))]
145 impl ToTokens for ast::Stmt {
146 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
147 let nt = token::NtStmt(self.clone());
148 let mut tts = vec![TokenTree::Token(self.span, Token::interpolated(nt))];
150 // Some statements require a trailing semicolon.
151 if classify::stmt_ends_with_semi(&self.node) {
152 tts.push(TokenTree::Token(self.span, token::Semi));
159 impl ToTokens for P<ast::Expr> {
160 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
161 let nt = token::NtExpr(self.clone());
162 vec![TokenTree::Token(self.span, Token::interpolated(nt))]
166 impl ToTokens for P<ast::Pat> {
167 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
168 let nt = token::NtPat(self.clone());
169 vec![TokenTree::Token(self.span, Token::interpolated(nt))]
173 impl ToTokens for ast::Arm {
174 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
175 let nt = token::NtArm(self.clone());
176 vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
180 impl ToTokens for ast::Arg {
181 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
182 let nt = token::NtArg(self.clone());
183 vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
187 impl ToTokens for P<ast::Block> {
188 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
189 let nt = token::NtBlock(self.clone());
190 vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
194 macro_rules! impl_to_tokens_slice {
195 ($t: ty, $sep: expr) => {
196 impl ToTokens for [$t] {
197 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
199 for (i, x) in self.iter().enumerate() {
201 v.extend_from_slice(&$sep);
203 v.extend(x.to_tokens(cx));
211 impl_to_tokens_slice! { ast::Ty, [TokenTree::Token(DUMMY_SP, token::Comma)] }
212 impl_to_tokens_slice! { P<ast::Item>, [] }
213 impl_to_tokens_slice! { ast::Arg, [TokenTree::Token(DUMMY_SP, token::Comma)] }
215 impl ToTokens for ast::MetaItem {
216 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
217 let nt = token::NtMeta(self.clone());
218 vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
222 impl ToTokens for ast::Attribute {
223 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
225 // FIXME: The spans could be better
226 r.push(TokenTree::Token(self.span, token::Pound));
227 if self.style == ast::AttrStyle::Inner {
228 r.push(TokenTree::Token(self.span, token::Not));
230 let mut inner = Vec::new();
231 for (i, segment) in self.path.segments.iter().enumerate() {
233 inner.push(TokenTree::Token(self.span, token::Colon).into());
235 inner.push(TokenTree::Token(self.span, token::Ident(segment.identifier)).into());
237 inner.push(self.tokens.clone());
239 r.push(TokenTree::Delimited(self.span, tokenstream::Delimited {
240 delim: token::Bracket, tts: TokenStream::concat(inner).into()
246 impl ToTokens for str {
247 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
248 let lit = ast::LitKind::Str(Symbol::intern(self), ast::StrStyle::Cooked);
249 dummy_spanned(lit).to_tokens(cx)
253 impl ToTokens for () {
254 fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
255 vec![TokenTree::Delimited(DUMMY_SP, tokenstream::Delimited {
257 tts: TokenStream::empty().into(),
262 impl ToTokens for ast::Lit {
263 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
264 // FIXME: This is wrong
266 id: ast::DUMMY_NODE_ID,
267 node: ast::ExprKind::Lit(P(self.clone())),
269 attrs: ast::ThinVec::new(),
274 impl ToTokens for bool {
275 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
276 dummy_spanned(ast::LitKind::Bool(*self)).to_tokens(cx)
280 impl ToTokens for char {
281 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
282 dummy_spanned(ast::LitKind::Char(*self)).to_tokens(cx)
286 macro_rules! impl_to_tokens_int {
287 (signed, $t:ty, $tag:expr) => (
288 impl ToTokens for $t {
289 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
290 let val = if *self < 0 {
295 let lit = ast::LitKind::Int(val as u128, ast::LitIntType::Signed($tag));
296 let lit = P(ast::Expr {
297 id: ast::DUMMY_NODE_ID,
298 node: ast::ExprKind::Lit(P(dummy_spanned(lit))),
300 attrs: ast::ThinVec::new(),
303 return lit.to_tokens(cx);
306 id: ast::DUMMY_NODE_ID,
307 node: ast::ExprKind::Unary(ast::UnOp::Neg, lit),
309 attrs: ast::ThinVec::new(),
314 (unsigned, $t:ty, $tag:expr) => (
315 impl ToTokens for $t {
316 fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
317 let lit = ast::LitKind::Int(*self as u128, ast::LitIntType::Unsigned($tag));
318 dummy_spanned(lit).to_tokens(cx)
324 impl_to_tokens_int! { signed, isize, ast::IntTy::Is }
325 impl_to_tokens_int! { signed, i8, ast::IntTy::I8 }
326 impl_to_tokens_int! { signed, i16, ast::IntTy::I16 }
327 impl_to_tokens_int! { signed, i32, ast::IntTy::I32 }
328 impl_to_tokens_int! { signed, i64, ast::IntTy::I64 }
330 impl_to_tokens_int! { unsigned, usize, ast::UintTy::Us }
331 impl_to_tokens_int! { unsigned, u8, ast::UintTy::U8 }
332 impl_to_tokens_int! { unsigned, u16, ast::UintTy::U16 }
333 impl_to_tokens_int! { unsigned, u32, ast::UintTy::U32 }
334 impl_to_tokens_int! { unsigned, u64, ast::UintTy::U64 }
336 pub trait ExtParseUtils {
337 fn parse_item(&self, s: String) -> P<ast::Item>;
338 fn parse_expr(&self, s: String) -> P<ast::Expr>;
339 fn parse_stmt(&self, s: String) -> ast::Stmt;
340 fn parse_tts(&self, s: String) -> Vec<TokenTree>;
343 impl<'a> ExtParseUtils for ExtCtxt<'a> {
344 fn parse_item(&self, s: String) -> P<ast::Item> {
345 panictry!(parse::parse_item_from_source_str(
346 "<quote expansion>".to_string(),
348 self.parse_sess())).expect("parse error")
351 fn parse_stmt(&self, s: String) -> ast::Stmt {
352 panictry!(parse::parse_stmt_from_source_str(
353 "<quote expansion>".to_string(),
355 self.parse_sess())).expect("parse error")
358 fn parse_expr(&self, s: String) -> P<ast::Expr> {
359 panictry!(parse::parse_expr_from_source_str(
360 "<quote expansion>".to_string(),
365 fn parse_tts(&self, s: String) -> Vec<TokenTree> {
366 let source_name = "<quote expansion>".to_owned();
367 parse::parse_stream_from_source_str(source_name, s, self.parse_sess(), None)
368 .into_trees().collect()
373 // Replaces `Token::OpenDelim .. Token::CloseDelim` with `TokenTree::Delimited(..)`.
374 pub fn unflatten(tts: Vec<TokenTree>) -> Vec<TokenTree> {
375 use tokenstream::Delimited;
377 let mut results = Vec::new();
378 let mut result = Vec::new();
381 TokenTree::Token(_, token::OpenDelim(..)) => {
382 results.push(::std::mem::replace(&mut result, Vec::new()));
384 TokenTree::Token(span, token::CloseDelim(delim)) => {
385 let tree = TokenTree::Delimited(span, Delimited {
387 tts: result.into_iter().map(TokenStream::from).collect::<TokenStream>().into(),
389 result = results.pop().unwrap();
392 tree => result.push(tree),
398 // These panicking parsing functions are used by the quote_*!() syntax extensions,
399 // but shouldn't be used otherwise.
400 pub fn parse_expr_panic(parser: &mut Parser) -> P<Expr> {
401 panictry!(parser.parse_expr())
404 pub fn parse_item_panic(parser: &mut Parser) -> Option<P<Item>> {
405 panictry!(parser.parse_item())
408 pub fn parse_pat_panic(parser: &mut Parser) -> P<Pat> {
409 panictry!(parser.parse_pat())
412 pub fn parse_arm_panic(parser: &mut Parser) -> Arm {
413 panictry!(parser.parse_arm())
416 pub fn parse_ty_panic(parser: &mut Parser) -> P<Ty> {
417 panictry!(parser.parse_ty())
420 pub fn parse_stmt_panic(parser: &mut Parser) -> Option<Stmt> {
421 panictry!(parser.parse_stmt())
424 pub fn parse_attribute_panic(parser: &mut Parser, permit_inner: bool) -> ast::Attribute {
425 panictry!(parser.parse_attribute(permit_inner))
428 pub fn parse_arg_panic(parser: &mut Parser) -> Arg {
429 panictry!(parser.parse_arg())
432 pub fn parse_block_panic(parser: &mut Parser) -> P<Block> {
433 panictry!(parser.parse_block())
436 pub fn parse_meta_item_panic(parser: &mut Parser) -> ast::MetaItem {
437 panictry!(parser.parse_meta_item())
440 pub fn parse_path_panic(parser: &mut Parser, mode: PathStyle) -> ast::Path {
441 panictry!(parser.parse_path(mode))
444 pub fn expand_quote_tokens<'cx>(cx: &'cx mut ExtCtxt,
447 -> Box<base::MacResult+'cx> {
448 let (cx_expr, expr) = expand_tts(cx, sp, tts);
449 let expanded = expand_wrapper(cx, sp, cx_expr, expr, &[&["syntax", "ext", "quote", "rt"]]);
450 base::MacEager::expr(expanded)
453 pub fn expand_quote_expr<'cx>(cx: &'cx mut ExtCtxt,
456 -> Box<base::MacResult+'cx> {
457 let expanded = expand_parse_call(cx, sp, "parse_expr_panic", vec![], tts);
458 base::MacEager::expr(expanded)
461 pub fn expand_quote_item<'cx>(cx: &'cx mut ExtCtxt,
464 -> Box<base::MacResult+'cx> {
465 let expanded = expand_parse_call(cx, sp, "parse_item_panic", vec![], tts);
466 base::MacEager::expr(expanded)
469 pub fn expand_quote_pat<'cx>(cx: &'cx mut ExtCtxt,
472 -> Box<base::MacResult+'cx> {
473 let expanded = expand_parse_call(cx, sp, "parse_pat_panic", vec![], tts);
474 base::MacEager::expr(expanded)
477 pub fn expand_quote_arm(cx: &mut ExtCtxt,
480 -> Box<base::MacResult+'static> {
481 let expanded = expand_parse_call(cx, sp, "parse_arm_panic", vec![], tts);
482 base::MacEager::expr(expanded)
485 pub fn expand_quote_ty(cx: &mut ExtCtxt,
488 -> Box<base::MacResult+'static> {
489 let expanded = expand_parse_call(cx, sp, "parse_ty_panic", vec![], tts);
490 base::MacEager::expr(expanded)
493 pub fn expand_quote_stmt(cx: &mut ExtCtxt,
496 -> Box<base::MacResult+'static> {
497 let expanded = expand_parse_call(cx, sp, "parse_stmt_panic", vec![], tts);
498 base::MacEager::expr(expanded)
501 pub fn expand_quote_attr(cx: &mut ExtCtxt,
504 -> Box<base::MacResult+'static> {
505 let expanded = expand_parse_call(cx, sp, "parse_attribute_panic",
506 vec![cx.expr_bool(sp, true)], tts);
508 base::MacEager::expr(expanded)
511 pub fn expand_quote_arg(cx: &mut ExtCtxt,
514 -> Box<base::MacResult+'static> {
515 let expanded = expand_parse_call(cx, sp, "parse_arg_panic", vec![], tts);
516 base::MacEager::expr(expanded)
519 pub fn expand_quote_block(cx: &mut ExtCtxt,
522 -> Box<base::MacResult+'static> {
523 let expanded = expand_parse_call(cx, sp, "parse_block_panic", vec![], tts);
524 base::MacEager::expr(expanded)
527 pub fn expand_quote_meta_item(cx: &mut ExtCtxt,
530 -> Box<base::MacResult+'static> {
531 let expanded = expand_parse_call(cx, sp, "parse_meta_item_panic", vec![], tts);
532 base::MacEager::expr(expanded)
535 pub fn expand_quote_path(cx: &mut ExtCtxt,
538 -> Box<base::MacResult+'static> {
539 let mode = mk_parser_path(cx, sp, &["PathStyle", "Type"]);
540 let expanded = expand_parse_call(cx, sp, "parse_path_panic", vec![mode], tts);
541 base::MacEager::expr(expanded)
544 fn ids_ext(strs: Vec<String>) -> Vec<ast::Ident> {
545 strs.iter().map(|s| ast::Ident::from_str(s)).collect()
548 fn id_ext(s: &str) -> ast::Ident {
549 ast::Ident::from_str(s)
552 // Lift an ident to the expr that evaluates to that ident.
553 fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
554 let e_str = cx.expr_str(sp, ident.name);
555 cx.expr_method_call(sp,
556 cx.expr_ident(sp, id_ext("ext_cx")),
561 // Lift a name to the expr that evaluates to that name
562 fn mk_name(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
563 let e_str = cx.expr_str(sp, ident.name);
564 cx.expr_method_call(sp,
565 cx.expr_ident(sp, id_ext("ext_cx")),
570 fn mk_tt_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
571 let idents = vec![id_ext("syntax"), id_ext("tokenstream"), id_ext("TokenTree"), id_ext(name)];
572 cx.expr_path(cx.path_global(sp, idents))
575 fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
576 let idents = vec![id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name)];
577 cx.expr_path(cx.path_global(sp, idents))
580 fn mk_parser_path(cx: &ExtCtxt, sp: Span, names: &[&str]) -> P<ast::Expr> {
581 let mut idents = vec![id_ext("syntax"), id_ext("parse"), id_ext("parser")];
582 idents.extend(names.iter().cloned().map(id_ext));
583 cx.expr_path(cx.path_global(sp, idents))
586 fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOpToken) -> P<ast::Expr> {
587 let name = match bop {
588 token::Plus => "Plus",
589 token::Minus => "Minus",
590 token::Star => "Star",
591 token::Slash => "Slash",
592 token::Percent => "Percent",
593 token::Caret => "Caret",
599 mk_token_path(cx, sp, name)
602 fn mk_delim(cx: &ExtCtxt, sp: Span, delim: token::DelimToken) -> P<ast::Expr> {
603 let name = match delim {
604 token::Paren => "Paren",
605 token::Bracket => "Bracket",
606 token::Brace => "Brace",
607 token::NoDelim => "NoDelim",
609 mk_token_path(cx, sp, name)
612 #[allow(non_upper_case_globals)]
613 fn expr_mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> {
614 macro_rules! mk_lit {
615 ($name: expr, $suffix: expr, $content: expr $(, $count: expr)*) => {{
616 let name = mk_name(cx, sp, ast::Ident::with_empty_ctxt($content));
617 let inner = cx.expr_call(sp, mk_token_path(cx, sp, $name), vec![
618 name $(, cx.expr_usize(sp, $count))*
620 let suffix = match $suffix {
621 Some(name) => cx.expr_some(sp, mk_name(cx, sp, ast::Ident::with_empty_ctxt(name))),
622 None => cx.expr_none(sp)
624 cx.expr_call(sp, mk_token_path(cx, sp, "Literal"), vec![inner, suffix])
628 let name = match *tok {
629 token::BinOp(binop) => {
630 return cx.expr_call(sp, mk_token_path(cx, sp, "BinOp"), vec![mk_binop(cx, sp, binop)]);
632 token::BinOpEq(binop) => {
633 return cx.expr_call(sp, mk_token_path(cx, sp, "BinOpEq"),
634 vec![mk_binop(cx, sp, binop)]);
637 token::OpenDelim(delim) => {
638 return cx.expr_call(sp, mk_token_path(cx, sp, "OpenDelim"),
639 vec![mk_delim(cx, sp, delim)]);
641 token::CloseDelim(delim) => {
642 return cx.expr_call(sp, mk_token_path(cx, sp, "CloseDelim"),
643 vec![mk_delim(cx, sp, delim)]);
646 token::Literal(token::Byte(i), suf) => return mk_lit!("Byte", suf, i),
647 token::Literal(token::Char(i), suf) => return mk_lit!("Char", suf, i),
648 token::Literal(token::Integer(i), suf) => return mk_lit!("Integer", suf, i),
649 token::Literal(token::Float(i), suf) => return mk_lit!("Float", suf, i),
650 token::Literal(token::Str_(i), suf) => return mk_lit!("Str_", suf, i),
651 token::Literal(token::StrRaw(i, n), suf) => return mk_lit!("StrRaw", suf, i, n),
652 token::Literal(token::ByteStr(i), suf) => return mk_lit!("ByteStr", suf, i),
653 token::Literal(token::ByteStrRaw(i, n), suf) => return mk_lit!("ByteStrRaw", suf, i, n),
655 token::Ident(ident) => {
656 return cx.expr_call(sp,
657 mk_token_path(cx, sp, "Ident"),
658 vec![mk_ident(cx, sp, ident)]);
661 token::Lifetime(ident) => {
662 return cx.expr_call(sp,
663 mk_token_path(cx, sp, "Lifetime"),
664 vec![mk_ident(cx, sp, ident)]);
667 token::DocComment(ident) => {
668 return cx.expr_call(sp,
669 mk_token_path(cx, sp, "DocComment"),
670 vec![mk_name(cx, sp, ast::Ident::with_empty_ctxt(ident))]);
673 token::Interpolated(_) => panic!("quote! with interpolated token"),
678 token::EqEq => "EqEq",
682 token::AndAnd => "AndAnd",
683 token::OrOr => "OrOr",
685 token::Tilde => "Tilde",
688 token::DotDot => "DotDot",
689 token::DotDotDot => "DotDotDot",
690 token::Comma => "Comma",
691 token::Semi => "Semi",
692 token::Colon => "Colon",
693 token::ModSep => "ModSep",
694 token::RArrow => "RArrow",
695 token::LArrow => "LArrow",
696 token::FatArrow => "FatArrow",
697 token::Pound => "Pound",
698 token::Dollar => "Dollar",
699 token::Question => "Question",
700 token::Underscore => "Underscore",
703 token::Whitespace | token::Comment | token::Shebang(_) => {
704 panic!("unhandled token in quote!");
707 mk_token_path(cx, sp, name)
710 fn statements_mk_tt(cx: &ExtCtxt, tt: &TokenTree, quoted: bool) -> Vec<ast::Stmt> {
712 TokenTree::Token(sp, token::Ident(ident)) if quoted => {
713 // tt.extend($ident.to_tokens(ext_cx))
716 cx.expr_method_call(sp,
717 cx.expr_ident(sp, ident),
719 vec![cx.expr_ident(sp, id_ext("ext_cx"))]);
721 cx.expr_method_call(sp, e_to_toks, id_ext("into_iter"), vec![]);
724 cx.expr_method_call(sp,
725 cx.expr_ident(sp, id_ext("tt")),
729 vec![cx.stmt_expr(e_push)]
731 TokenTree::Token(sp, ref tok) => {
732 let e_sp = cx.expr_ident(sp, id_ext("_sp"));
733 let e_tok = cx.expr_call(sp,
734 mk_tt_path(cx, sp, "Token"),
735 vec![e_sp, expr_mk_token(cx, sp, tok)]);
737 cx.expr_method_call(sp,
738 cx.expr_ident(sp, id_ext("tt")),
741 vec![cx.stmt_expr(e_push)]
743 TokenTree::Delimited(span, ref delimed) => {
744 let mut stmts = statements_mk_tt(cx, &delimed.open_tt(span), false);
745 stmts.extend(statements_mk_tts(cx, delimed.stream()));
746 stmts.extend(statements_mk_tt(cx, &delimed.close_tt(span), false));
752 fn parse_arguments_to_quote(cx: &ExtCtxt, tts: &[TokenTree])
753 -> (P<ast::Expr>, Vec<TokenTree>) {
754 let mut p = cx.new_parser_from_tts(tts);
756 let cx_expr = panictry!(p.parse_expr());
757 if !p.eat(&token::Comma) {
758 let _ = p.diagnostic().fatal("expected token `,`");
761 let tts = panictry!(p.parse_all_token_trees());
767 fn mk_stmts_let(cx: &ExtCtxt, sp: Span) -> Vec<ast::Stmt> {
768 // We also bind a single value, sp, to ext_cx.call_site()
770 // This causes every span in a token-tree quote to be attributed to the
771 // call site of the extension using the quote. We can't really do much
772 // better since the source of the quote may well be in a library that
773 // was not even parsed by this compilation run, that the user has no
774 // source code for (eg. in libsyntax, which they're just _using_).
776 // The old quasiquoter had an elaborate mechanism for denoting input
777 // file locations from which quotes originated; unfortunately this
778 // relied on feeding the source string of the quote back into the
779 // compiler (which we don't really want to do) and, in any case, only
780 // pushed the problem a very small step further back: an error
781 // resulting from a parse of the resulting quote is still attributed to
782 // the site the string literal occurred, which was in a source file
783 // _other_ than the one the user has control over. For example, an
784 // error in a quote from the protocol compiler, invoked in user code
785 // using macro_rules! for example, will be attributed to the macro_rules.rs
786 // file in libsyntax, which the user might not even have source to (unless
787 // they happen to have a compiler on hand). Over all, the phase distinction
788 // just makes quotes "hard to attribute". Possibly this could be fixed
789 // by recreating some of the original qq machinery in the tt regime
790 // (pushing fake FileMaps onto the parser to account for original sites
791 // of quotes, for example) but at this point it seems not likely to be
794 let e_sp = cx.expr_method_call(sp,
795 cx.expr_ident(sp, id_ext("ext_cx")),
799 let stmt_let_sp = cx.stmt_let(sp, false,
803 let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp));
805 vec![stmt_let_sp, stmt_let_tt]
808 fn statements_mk_tts(cx: &ExtCtxt, tts: TokenStream) -> Vec<ast::Stmt> {
809 let mut ss = Vec::new();
810 let mut quoted = false;
811 for tt in tts.into_trees() {
813 TokenTree::Token(_, token::Dollar) if !quoted => true,
815 ss.extend(statements_mk_tt(cx, &tt, quoted));
823 fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[TokenTree]) -> (P<ast::Expr>, P<ast::Expr>) {
824 let (cx_expr, tts) = parse_arguments_to_quote(cx, tts);
826 let mut vector = mk_stmts_let(cx, sp);
827 vector.extend(statements_mk_tts(cx, tts.iter().cloned().collect()));
828 vector.push(cx.stmt_expr(cx.expr_ident(sp, id_ext("tt"))));
829 let block = cx.expr_block(cx.block(sp, vector));
830 let unflatten = vec![id_ext("syntax"), id_ext("ext"), id_ext("quote"), id_ext("unflatten")];
832 (cx_expr, cx.expr_call_global(sp, unflatten, vec![block]))
835 fn expand_wrapper(cx: &ExtCtxt,
837 cx_expr: P<ast::Expr>,
839 imports: &[&[&str]]) -> P<ast::Expr> {
840 // Explicitly borrow to avoid moving from the invoker (#16992)
841 let cx_expr_borrow = cx.expr_addr_of(sp, cx.expr_deref(sp, cx_expr));
842 let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr_borrow);
844 let mut stmts = imports.iter().map(|path| {
845 // make item: `use ...;`
846 let path = path.iter().map(|s| s.to_string()).collect();
847 cx.stmt_item(sp, cx.item_use_glob(sp, ast::Visibility::Inherited, ids_ext(path)))
848 }).chain(Some(stmt_let_ext_cx)).collect::<Vec<_>>();
849 stmts.push(cx.stmt_expr(expr));
851 cx.expr_block(cx.block(sp, stmts))
854 fn expand_parse_call(cx: &ExtCtxt,
857 arg_exprs: Vec<P<ast::Expr>> ,
858 tts: &[TokenTree]) -> P<ast::Expr> {
859 let (cx_expr, tts_expr) = expand_tts(cx, sp, tts);
861 let parse_sess_call = || cx.expr_method_call(
862 sp, cx.expr_ident(sp, id_ext("ext_cx")),
863 id_ext("parse_sess"), Vec::new());
865 let new_parser_call =
867 cx.expr_ident(sp, id_ext("new_parser_from_tts")),
868 vec![parse_sess_call(), tts_expr]);
870 let path = vec![id_ext("syntax"), id_ext("ext"), id_ext("quote"), id_ext(parse_method)];
871 let mut args = vec![cx.expr_mut_addr_of(sp, new_parser_call)];
872 args.extend(arg_exprs);
873 let expr = cx.expr_call_global(sp, path, args);
875 if parse_method == "parse_attribute" {
876 expand_wrapper(cx, sp, cx_expr, expr, &[&["syntax", "ext", "quote", "rt"],
877 &["syntax", "parse", "attr"]])
879 expand_wrapper(cx, sp, cx_expr, expr, &[&["syntax", "ext", "quote", "rt"]])