src/libsyntax/ext/quote.rs

   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.
   4 //
   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.
  10
  11 use ast;
  12 use codemap::Span;
  13 use ext::base::ExtCtxt;
  14 use ext::base;
  15 use ext::build::AstBuilder;
  16 use parse::token::*;
  17 use parse::token;
  18 use ptr::P;
  19
  20 ///  Quasiquoting works via token trees.
  21 ///
  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).
  26
  27 pub mod rt {
  28     use ast;
  29     use codemap::Spanned;
  30     use ext::base::ExtCtxt;
  31     use parse::token;
  32     use parse;
  33     use print::pprust;
  34     use ptr::P;
  35
  36     use ast::{TokenTree, Generics, Expr};
  37
  38     pub use parse::new_parser_from_tts;
  39     pub use codemap::{BytePos, Span, dummy_spanned};
  40
  41     pub trait ToTokens {
  42         fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> ;
  43     }
  44
  45     impl ToTokens for TokenTree {
  46         fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
  47             vec!(self.clone())
  48         }
  49     }
  50
  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()
  54         }
  55     }
  56
  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)
  61         }
  62     }
  63
  64     impl<T: ToTokens> ToTokens for Option<T> {
  65         fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
  66             match self {
  67                 &Some(ref t) => t.to_tokens(cx),
  68                 &None => Vec::new(),
  69             }
  70         }
  71     }
  72
  73     /* Should be (when bugs in default methods are fixed):
  74
  75     trait ToSource : ToTokens {
  76         // Takes a thing and generates a string containing rust code for it.
  77         pub fn to_source() -> String;
  78
  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())
  82         }
  83     }
  84
  85     */
  86
  87     // FIXME: Move this trait to pprust and get rid of *_to_str?
  88     pub trait ToSource {
  89         // Takes a thing and generates a string containing rust code for it.
  90         fn to_source(&self) -> String;
  91     }
  92
  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;
 100     }
 101
 102     macro_rules! impl_to_source {
 103         (P<$t:ty>, $pp:ident) => (
 104             impl ToSource for P<$t> {
 105                 fn to_source(&self) -> String {
 106                     pprust::$pp(&**self)
 107                 }
 108             }
 109             impl ToSourceWithHygiene for P<$t> {
 110                 fn to_source_with_hygiene(&self) -> String {
 111                     pprust::with_hygiene::$pp(&**self)
 112                 }
 113             }
 114         );
 115         ($t:ty, $pp:ident) => (
 116             impl ToSource for $t {
 117                 fn to_source(&self) -> String {
 118                     pprust::$pp(self)
 119                 }
 120             }
 121             impl ToSourceWithHygiene for $t {
 122                 fn to_source_with_hygiene(&self) -> String {
 123                     pprust::with_hygiene::$pp(self)
 124                 }
 125             }
 126         );
 127     }
 128
 129     fn slice_to_source<'a, T: ToSource>(sep: &'static str, xs: &'a [T]) -> String {
 130         xs.iter()
 131             .map(|i| i.to_source())
 132             .collect::<Vec<String>>()
 133             .connect(sep)
 134             .to_string()
 135     }
 136
 137     fn slice_to_source_with_hygiene<'a, T: ToSourceWithHygiene>(
 138         sep: &'static str, xs: &'a [T]) -> String {
 139         xs.iter()
 140             .map(|i| i.to_source_with_hygiene())
 141             .collect::<Vec<String>>()
 142             .connect(sep)
 143             .to_string()
 144     }
 145
 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)
 151                 }
 152             }
 153
 154             impl ToSourceWithHygiene for [$t] {
 155                 fn to_source_with_hygiene(&self) -> String {
 156                     slice_to_source_with_hygiene($sep, self)
 157                 }
 158             }
 159         )
 160     }
 161
 162     impl ToSource for ast::Ident {
 163         fn to_source(&self) -> String {
 164             token::get_ident(*self).get().to_string()
 165         }
 166     }
 167
 168     impl ToSourceWithHygiene for ast::Ident {
 169         fn to_source_with_hygiene(&self) -> String {
 170             self.encode_with_hygiene()
 171         }
 172     }
 173
 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" }
 186
 187     impl ToSource for ast::Attribute_ {
 188         fn to_source(&self) -> String {
 189             pprust::attribute_to_string(&dummy_spanned(self.clone()))
 190         }
 191     }
 192     impl ToSourceWithHygiene for ast::Attribute_ {
 193         fn to_source_with_hygiene(&self) -> String {
 194             self.to_source()
 195         }
 196     }
 197
 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)
 203         }
 204     }
 205     impl ToSourceWithHygiene for str {
 206         fn to_source_with_hygiene(&self) -> String {
 207             self.to_source()
 208         }
 209     }
 210
 211     impl ToSource for () {
 212         fn to_source(&self) -> String {
 213             "()".to_string()
 214         }
 215     }
 216     impl ToSourceWithHygiene for () {
 217         fn to_source_with_hygiene(&self) -> String {
 218             self.to_source()
 219         }
 220     }
 221
 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)
 226         }
 227     }
 228     impl ToSourceWithHygiene for bool {
 229         fn to_source_with_hygiene(&self) -> String {
 230             self.to_source()
 231         }
 232     }
 233
 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)
 238         }
 239     }
 240     impl ToSourceWithHygiene for char {
 241         fn to_source_with_hygiene(&self) -> String {
 242             self.to_source()
 243         }
 244     }
 245
 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))
 253                 }
 254             }
 255             impl ToSourceWithHygiene for $t {
 256                 fn to_source_with_hygiene(&self) -> String {
 257                     self.to_source()
 258                 }
 259             }
 260         );
 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))
 266                 }
 267             }
 268             impl ToSourceWithHygiene for $t {
 269                 fn to_source_with_hygiene(&self) -> String {
 270                     self.to_source()
 271                 }
 272             }
 273         );
 274     }
 275
 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 }
 281
 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 }
 287
 288     // Alas ... we write these out instead. All redundant.
 289
 290     macro_rules! impl_to_tokens {
 291         ($t:ty) => (
 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())
 295                 }
 296             }
 297         )
 298     }
 299
 300     macro_rules! impl_to_tokens_lifetime {
 301         ($t:ty) => (
 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())
 305                 }
 306             }
 307         )
 308     }
 309
 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 }
 338
 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>;
 344     }
 345
 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>;
 350     }
 351
 352     impl<'a> ExtParseUtils for ExtCtxt<'a> {
 353
 354         fn parse_item(&self, s: String) -> P<ast::Item> {
 355             parse::parse_item_from_source_str(
 356                 "<quote expansion>".to_string(),
 357                 s,
 358                 self.cfg(),
 359                 self.parse_sess()).expect("parse error")
 360         }
 361
 362         fn parse_stmt(&self, s: String) -> P<ast::Stmt> {
 363             parse::parse_stmt_from_source_str("<quote expansion>".to_string(),
 364                                               s,
 365                                               self.cfg(),
 366                                               Vec::new(),
 367                                               self.parse_sess())
 368         }
 369
 370         fn parse_expr(&self, s: String) -> P<ast::Expr> {
 371             parse::parse_expr_from_source_str("<quote expansion>".to_string(),
 372                                               s,
 373                                               self.cfg(),
 374                                               self.parse_sess())
 375         }
 376
 377         fn parse_tts(&self, s: String) -> Vec<ast::TokenTree> {
 378             parse::parse_tts_from_source_str("<quote expansion>".to_string(),
 379                                              s,
 380                                              self.cfg(),
 381                                              self.parse_sess())
 382         }
 383     }
 384
 385     impl<'a> ExtParseUtilsWithHygiene for ExtCtxt<'a> {
 386
 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(),
 390                                       s,
 391                                       self.cfg(),
 392                                       self.parse_sess())
 393         }
 394
 395     }
 396
 397 }
 398
 399 pub fn expand_quote_tokens<'cx>(cx: &'cx mut ExtCtxt,
 400                                 sp: Span,
 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)
 406 }
 407
 408 pub fn expand_quote_expr<'cx>(cx: &'cx mut ExtCtxt,
 409                               sp: Span,
 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)
 414 }
 415
 416 pub fn expand_quote_item<'cx>(cx: &mut ExtCtxt,
 417                               sp: Span,
 418                               tts: &[ast::TokenTree])
 419                               -> Box<base::MacResult+'cx> {
 420     let expanded = expand_parse_call(cx, sp, "parse_item_with_outer_attributes",
 421                                     vec!(), tts);
 422     base::MacExpr::new(expanded)
 423 }
 424
 425 pub fn expand_quote_pat<'cx>(cx: &'cx mut ExtCtxt,
 426                              sp: Span,
 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)
 431 }
 432
 433 pub fn expand_quote_arm(cx: &mut ExtCtxt,
 434                         sp: Span,
 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)
 439 }
 440
 441 pub fn expand_quote_ty(cx: &mut ExtCtxt,
 442                        sp: Span,
 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)
 447 }
 448
 449 pub fn expand_quote_method(cx: &mut ExtCtxt,
 450                            sp: Span,
 451                            tts: &[ast::TokenTree])
 452                            -> Box<base::MacResult+'static> {
 453     let expanded = expand_parse_call(cx, sp, "parse_method_with_outer_attributes",
 454                                      vec!(), tts);
 455     base::MacExpr::new(expanded)
 456 }
 457
 458 pub fn expand_quote_stmt(cx: &mut ExtCtxt,
 459                          sp: Span,
 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",
 464                                     vec!(e_attrs), tts);
 465     base::MacExpr::new(expanded)
 466 }
 467
 468 fn ids_ext(strs: Vec<String> ) -> Vec<ast::Ident> {
 469     strs.iter().map(|str| str_to_ident(&(*str)[])).collect()
 470 }
 471
 472 fn id_ext(str: &str) -> ast::Ident {
 473     str_to_ident(str)
 474 }
 475
 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")),
 481                         id_ext("ident_of"),
 482                         vec!(e_str))
 483 }
 484
 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")),
 490                         id_ext("name_of"),
 491                         vec!(e_str))
 492 }
 493
 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))
 497 }
 498
 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))
 502 }
 503
 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",
 512         token::And      => "And",
 513         token::Or       => "Or",
 514         token::Shl      => "Shl",
 515         token::Shr      => "Shr"
 516     };
 517     mk_token_path(cx, sp, name)
 518 }
 519
 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",
 525     };
 526     mk_token_path(cx, sp, name)
 527 }
 528
 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)
 537             };
 538             cx.expr_call(sp, mk_token_path(cx, sp, "Literal"), vec![inner, suffix])
 539         }}
 540     }
 541     match *tok {
 542         token::BinOp(binop) => {
 543             return cx.expr_call(sp, mk_token_path(cx, sp, "BinOp"), vec!(mk_binop(cx, sp, binop)));
 544         }
 545         token::BinOpEq(binop) => {
 546             return cx.expr_call(sp, mk_token_path(cx, sp, "BinOpEq"),
 547                                 vec!(mk_binop(cx, sp, binop)));
 548         }
 549
 550         token::OpenDelim(delim) => {
 551             return cx.expr_call(sp, mk_token_path(cx, sp, "OpenDelim"),
 552                                 vec![mk_delim(cx, sp, delim)]);
 553         }
 554         token::CloseDelim(delim) => {
 555             return cx.expr_call(sp, mk_token_path(cx, sp, "CloseDelim"),
 556                                 vec![mk_delim(cx, sp, delim)]);
 557         }
 558
 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);
 562         }
 563
 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);
 567         }
 568
 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);
 572         }
 573
 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);
 577         }
 578
 579         token::Literal(token::Str_(ident), suf) => {
 580             return mk_lit!("Str_", suf, mk_name(cx, sp, ident.ident()))
 581         }
 582
 583         token::Literal(token::StrRaw(ident, n), suf) => {
 584             return mk_lit!("StrRaw", suf, mk_name(cx, sp, ident.ident()), cx.expr_usize(sp, n))
 585         }
 586
 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),
 591                                      match style {
 592                                         ModName => mk_token_path(cx, sp, "ModName"),
 593                                         Plain   => mk_token_path(cx, sp, "Plain"),
 594                                      }]);
 595         }
 596
 597         token::Lifetime(ident) => {
 598             return cx.expr_call(sp,
 599                                 mk_token_path(cx, sp, "Lifetime"),
 600                                 vec!(mk_ident(cx, sp, ident)));
 601         }
 602
 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())));
 607         }
 608
 609         token::Interpolated(_) => panic!("quote! with interpolated token"),
 610
 611         _ => ()
 612     }
 613
 614     let name = match *tok {
 615         token::Eq           => "Eq",
 616         token::Lt           => "Lt",
 617         token::Le           => "Le",
 618         token::EqEq         => "EqEq",
 619         token::Ne           => "Ne",
 620         token::Ge           => "Ge",
 621         token::Gt           => "Gt",
 622         token::AndAnd       => "AndAnd",
 623         token::OrOr         => "OrOr",
 624         token::Not          => "Not",
 625         token::Tilde        => "Tilde",
 626         token::At           => "At",
 627         token::Dot          => "Dot",
 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",
 639         token::Eof          => "Eof",
 640         _                   => panic!(),
 641     };
 642     mk_token_path(cx, sp, name)
 643 }
 644
 645 fn mk_tt(cx: &ExtCtxt, tt: &ast::TokenTree) -> Vec<P<ast::Stmt>> {
 646     match *tt {
 647         ast::TtToken(sp, SubstNt(ident, _)) => {
 648             // tt.extend($ident.to_tokens(ext_cx).into_iter())
 649
 650             let e_to_toks =
 651                 cx.expr_method_call(sp,
 652                                     cx.expr_ident(sp, ident),
 653                                     id_ext("to_tokens"),
 654                                     vec!(cx.expr_ident(sp, id_ext("ext_cx"))));
 655             let e_to_toks =
 656                 cx.expr_method_call(sp, e_to_toks, id_ext("into_iter"), vec![]);
 657
 658             let e_push =
 659                 cx.expr_method_call(sp,
 660                                     cx.expr_ident(sp, id_ext("tt")),
 661                                     id_ext("extend"),
 662                                     vec!(e_to_toks));
 663
 664             vec!(cx.stmt_expr(e_push))
 665         }
 666         ref tt @ ast::TtToken(_, MatchNt(..)) => {
 667             let mut seq = vec![];
 668             for i in 0..tt.len() {
 669                 seq.push(tt.get_tt(i));
 670             }
 671             mk_tts(cx, &seq[])
 672         }
 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)));
 678             let e_push =
 679                 cx.expr_method_call(sp,
 680                                     cx.expr_ident(sp, id_ext("tt")),
 681                                     id_ext("push"),
 682                                     vec!(e_tok));
 683             vec!(cx.stmt_expr(e_push))
 684         },
 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())
 689                 .collect()
 690         },
 691         ast::TtSequence(..) => panic!("TtSequence in quote!"),
 692     }
 693 }
 694
 695 fn mk_tts(cx: &ExtCtxt, tts: &[ast::TokenTree]) -> Vec<P<ast::Stmt>> {
 696     let mut ss = Vec::new();
 697     for tt in tts {
 698         ss.extend(mk_tt(cx, tt).into_iter());
 699     }
 700     ss
 701 }
 702
 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.
 710
 711     let mut p = cx.new_parser_from_tts(tts);
 712     p.quote_depth += 1;
 713
 714     let cx_expr = p.parse_expr();
 715     if !p.eat(&token::Comma) {
 716         p.fatal("expected token `,`");
 717     }
 718
 719     let tts = p.parse_all_token_trees();
 720     p.abort_if_errors();
 721
 722     // We also bind a single value, sp, to ext_cx.call_site()
 723     //
 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_).
 729     //
 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
 746     // worth the hassle.
 747
 748     let e_sp = cx.expr_method_call(sp,
 749                                    cx.expr_ident(sp, id_ext("ext_cx")),
 750                                    id_ext("call_site"),
 751                                    Vec::new());
 752
 753     let stmt_let_sp = cx.stmt_let(sp, false,
 754                                   id_ext("_sp"),
 755                                   e_sp);
 756
 757     let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp));
 758
 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(
 762         cx.block_all(sp,
 763                      vector,
 764                      Some(cx.expr_ident(sp, id_ext("tt")))));
 765
 766     (cx_expr, block)
 767 }
 768
 769 fn expand_wrapper(cx: &ExtCtxt,
 770                   sp: Span,
 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);
 776
 777     let stmts = [
 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();
 783
 784     cx.expr_block(cx.block_all(sp, stmts, Some(expr)))
 785 }
 786
 787 fn expand_parse_call(cx: &ExtCtxt,
 788                      sp: Span,
 789                      parse_method: &str,
 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);
 793
 794     let cfg_call = |&:| cx.expr_method_call(
 795         sp, cx.expr_ident(sp, id_ext("ext_cx")),
 796         id_ext("cfg"), Vec::new());
 797
 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());
 801
 802     let new_parser_call =
 803         cx.expr_call(sp,
 804                      cx.expr_ident(sp, id_ext("new_parser_from_tts")),
 805                      vec!(parse_sess_call(), cfg_call(), tts_expr));
 806
 807     let expr = cx.expr_method_call(sp, new_parser_call, id_ext(parse_method),
 808                                    arg_exprs);
 809
 810     expand_wrapper(cx, sp, cx_expr, expr)
 811 }