OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove quote_*! macros and associated APIs

Browse Source
This commit is contained in:
Mark Simulacrum 2018-06-01 16:40:33 -06:00 committed by Mark Rousskov
parent 6bba352cad
commit db97c48ad6
60 changed files with 55 additions and 2217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/bootstrap/builder.rs
View File

@ -378,14 +378,11 @@ impl<'a> Builder<'a> {
test::Debuginfo,
test::UiFullDeps,
test::RunPassFullDeps,
test::RunFailFullDeps,
test::Rustdoc,
test::Pretty,
test::RunPassPretty,
test::RunFailPretty,
test::RunPassValgrindPretty,
test::RunPassFullDepsPretty,
test::RunFailFullDepsPretty,
test::Crate,
test::CrateLibrustc,
test::CrateRustdoc,

1
src/bootstrap/mk/Makefile.in
View File

@ -53,7 +53,6 @@ check-aux:
src/test/run-fail/pretty \
src/test/run-pass-valgrind/pretty \
src/test/run-pass-fulldeps/pretty \
src/test/run-fail-fulldeps/pretty \
$(AUX_ARGS) \
$(BOOTSTRAP_ARGS)
check-bootstrap:

20
src/bootstrap/test.rs
View File

@ -848,12 +848,6 @@ host_test!(RunPassFullDeps {
suite: "run-pass-fulldeps"
});
host_test!(RunFailFullDeps {
path: "src/test/run-fail-fulldeps",
mode: "run-fail",
suite: "run-fail-fulldeps"
});
host_test!(Rustdoc {
path: "src/test/rustdoc",
mode: "rustdoc",
@ -888,20 +882,6 @@ test!(RunPassValgrindPretty {
default: false,
host: true
});
test!(RunPassFullDepsPretty {
path: "src/test/run-pass-fulldeps/pretty",
mode: "pretty",
suite: "run-pass-fulldeps",
default: false,
host: true
});
test!(RunFailFullDepsPretty {
path: "src/test/run-fail-fulldeps/pretty",
mode: "pretty",
suite: "run-fail-fulldeps",
default: false,
host: true
});
default_test!(RunMake {
path: "src/test/run-make",

3
src/doc/unstable-book/src/language-features/plugin.md
View File

@ -52,6 +52,7 @@ that implements Roman numeral integer literals.
#![feature(plugin_registrar, rustc_private)]
extern crate syntax;
extern crate syntax_pos;
extern crate rustc;
extern crate rustc_plugin;
@ -59,7 +60,7 @@ use syntax::parse::token;
use syntax::tokenstream::TokenTree;
use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager};
use syntax::ext::build::AstBuilder; // A trait for expr_usize.
use syntax::ext::quote::rt::Span;
use syntax_pos::Span;
use rustc_plugin::Registry;
fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])

1
src/librustc/lib.rs
View File

@ -41,7 +41,6 @@
#![feature(nll)]
#![feature(non_exhaustive)]
#![feature(proc_macro_internals)]
#![feature(quote)]
#![feature(optin_builtin_traits)]
#![feature(refcell_replace_swap)]
#![feature(rustc_diagnostic_macros)]

1
src/librustc_borrowck/lib.rs
View File

@ -5,7 +5,6 @@
#![allow(non_camel_case_types)]
#![feature(nll)]
#![feature(quote)]
#![recursion_limit="256"]

1
src/librustc_codegen_llvm/lib.rs
View File

@ -17,7 +17,6 @@
#![allow(unused_attributes)]
#![feature(libc)]
#![feature(nll)]
#![feature(quote)]
#![feature(range_contains)]
#![feature(rustc_diagnostic_macros)]
#![feature(slice_sort_by_cached_key)]

1
src/librustc_codegen_ssa/lib.rs
View File

@ -12,7 +12,6 @@
#![feature(nll)]
#![allow(unused_attributes)]
#![allow(dead_code)]
#![feature(quote)]
#![recursion_limit="256"]

1
src/librustc_codegen_utils/lib.rs
View File

@ -11,7 +11,6 @@
#![feature(custom_attribute)]
#![feature(nll)]
#![allow(unused_attributes)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![recursion_limit="256"]

2
src/librustc_driver/driver.rs
View File

@ -916,7 +916,7 @@ where
crate_loader,
&resolver_arenas,
);
syntax_ext::register_builtins(&mut resolver, syntax_exts, sess.features_untracked().quote);
syntax_ext::register_builtins(&mut resolver, syntax_exts);
// Expand all macros
sess.profiler(|p| p.start_activity(ProfileCategory::Expansion));

1
src/librustc_driver/lib.rs
View File

@ -11,7 +11,6 @@
#![feature(box_syntax)]
#![cfg_attr(unix, feature(libc))]
#![feature(nll)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![feature(slice_sort_by_cached_key)]
#![feature(set_stdio)]

1
src/librustc_lint/lib.rs
View File

@ -17,7 +17,6 @@
#![feature(box_patterns)]
#![feature(box_syntax)]
#![feature(nll)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![recursion_limit="256"]

1
src/librustc_metadata/lib.rs
View File

@ -7,7 +7,6 @@
#![feature(nll)]
#![feature(proc_macro_internals)]
#![feature(proc_macro_quote)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![feature(slice_sort_by_cached_key)]
#![feature(crate_visibility_modifier)]

1
src/librustc_typeck/lib.rs
View File

@ -66,7 +66,6 @@ This API is completely unstable and subject to change.
#![feature(crate_visibility_modifier)]
#![feature(exhaustive_patterns)]
#![feature(nll)]
#![feature(quote)]
#![feature(refcell_replace_swap)]
#![feature(rustc_diagnostic_macros)]
#![feature(slice_patterns)]

893
src/libsyntax/ext/quote.rs
View File

@ -1,893 +0,0 @@
use ast::{self, Arg, Arm, Block, Expr, Item, Pat, Stmt, Ty};
use source_map::respan;
use syntax_pos::{Span, DUMMY_SP};
use ext::base::ExtCtxt;
use ext::base;
use ext::build::AstBuilder;
use parse::parser::{Parser, PathStyle};
use parse::token;
use ptr::P;
use tokenstream::{DelimSpan, TokenStream, TokenTree};
/// Quasiquoting works via token trees.
///
/// This is registered as a set of expression syntax extension called quote!
/// that lifts its argument token-tree to an AST representing the
/// construction of the same token tree, with `token::SubstNt` interpreted
/// as antiquotes (splices).
pub mod rt {
use ast;
use source_map::Spanned;
use ext::base::ExtCtxt;
use parse::{self, classify};
use parse::token::{self, Token};
use ptr::P;
use symbol::Symbol;
use ThinVec;
use tokenstream::{DelimSpan, TokenTree, TokenStream};
pub use parse::new_parser_from_tts;
pub use syntax_pos::{BytePos, Span, DUMMY_SP, FileName};
pub use source_map::{dummy_spanned};
pub trait ToTokens {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree>;
}
impl ToTokens for TokenTree {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
vec![self.clone()]
}
}
impl<T: ToTokens> ToTokens for Vec<T> {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
self.iter().flat_map(|t| t.to_tokens(cx)).collect()
}
}
impl<T: ToTokens> ToTokens for Spanned<T> {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
// FIXME: use the span?
self.node.to_tokens(cx)
}
}
impl<T: ToTokens> ToTokens for Option<T> {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
match *self {
Some(ref t) => t.to_tokens(cx),
None => Vec::new(),
}
}
}
impl ToTokens for ast::Ident {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
vec![TokenTree::Token(self.span, Token::from_ast_ident(*self))]
}
}
impl ToTokens for ast::Path {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtPath(self.clone());
vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
}
}
impl ToTokens for ast::Ty {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtTy(P(self.clone()));
vec![TokenTree::Token(self.span, Token::interpolated(nt))]
}
}
impl ToTokens for ast::Block {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtBlock(P(self.clone()));
vec![TokenTree::Token(self.span, Token::interpolated(nt))]
}
}
impl ToTokens for ast::Generics {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtGenerics(self.clone());
vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
}
}
impl ToTokens for ast::WhereClause {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtWhereClause(self.clone());
vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
}
}
impl ToTokens for P<ast::Item> {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtItem(self.clone());
vec![TokenTree::Token(self.span, Token::interpolated(nt))]
}
}
impl ToTokens for ast::ImplItem {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtImplItem(self.clone());
vec![TokenTree::Token(self.span, Token::interpolated(nt))]
}
}
impl ToTokens for P<ast::ImplItem> {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtImplItem((**self).clone());
vec![TokenTree::Token(self.span, Token::interpolated(nt))]
}
}
impl ToTokens for ast::TraitItem {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtTraitItem(self.clone());
vec![TokenTree::Token(self.span, Token::interpolated(nt))]
}
}
impl ToTokens for ast::Stmt {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtStmt(self.clone());
let mut tts = vec![TokenTree::Token(self.span, Token::interpolated(nt))];
// Some statements require a trailing semicolon.
if classify::stmt_ends_with_semi(&self.node) {
tts.push(TokenTree::Token(self.span, token::Semi));
}
tts
}
}
impl ToTokens for P<ast::Expr> {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtExpr(self.clone());
vec![TokenTree::Token(self.span, Token::interpolated(nt))]
}
}
impl ToTokens for P<ast::Pat> {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtPat(self.clone());
vec![TokenTree::Token(self.span, Token::interpolated(nt))]
}
}
impl ToTokens for ast::Arm {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtArm(self.clone());
vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
}
}
impl ToTokens for ast::Arg {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtArg(self.clone());
vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
}
}
impl ToTokens for P<ast::Block> {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtBlock(self.clone());
vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
}
}
impl ToTokens for ast::Lifetime {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
vec![TokenTree::Token(self.ident.span, token::Lifetime(self.ident))]
}
}
macro_rules! impl_to_tokens_slice {
($t: ty, $sep: expr) => {
impl ToTokens for [$t] {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
let mut v = vec![];
for (i, x) in self.iter().enumerate() {
if i > 0 {
v.extend_from_slice(&$sep);
}
v.extend(x.to_tokens(cx));
}
v
}
}
};
}
impl_to_tokens_slice! { ast::Ty, [TokenTree::Token(DUMMY_SP, token::Comma)] }
impl_to_tokens_slice! { P<ast::Item>, [] }
impl_to_tokens_slice! { ast::Arg, [TokenTree::Token(DUMMY_SP, token::Comma)] }
impl ToTokens for ast::MetaItem {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let nt = token::NtMeta(self.clone());
vec![TokenTree::Token(DUMMY_SP, Token::interpolated(nt))]
}
}
impl ToTokens for ast::Attribute {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let mut r = vec![];
// FIXME: The spans could be better
r.push(TokenTree::Token(self.span, token::Pound));
if self.style == ast::AttrStyle::Inner {
r.push(TokenTree::Token(self.span, token::Not));
}
let mut inner = Vec::new();
for (i, segment) in self.path.segments.iter().enumerate() {
if i > 0 {
inner.push(TokenTree::Token(self.span, token::Colon).into());
}
inner.push(TokenTree::Token(
self.span, token::Token::from_ast_ident(segment.ident)
).into());
}
self.tokens.clone().append_to_tree_and_joint_vec(&mut inner);
let delim_span = DelimSpan::from_single(self.span);
r.push(TokenTree::Delimited(
delim_span, token::Bracket, TokenStream::new(inner).into()
));
r
}
}
impl ToTokens for str {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
let lit = ast::LitKind::Str(Symbol::intern(self), ast::StrStyle::Cooked);
dummy_spanned(lit).to_tokens(cx)
}
}
impl ToTokens for () {
fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
vec![
TokenTree::Delimited(DelimSpan::dummy(), token::Paren, TokenStream::empty().into())
]
}
}
impl ToTokens for ast::Lit {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
// FIXME: This is wrong
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprKind::Lit(self.clone()),
span: DUMMY_SP,
attrs: ThinVec::new(),
}).to_tokens(cx)
}
}
impl ToTokens for bool {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
dummy_spanned(ast::LitKind::Bool(*self)).to_tokens(cx)
}
}
impl ToTokens for char {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
dummy_spanned(ast::LitKind::Char(*self)).to_tokens(cx)
}
}
macro_rules! impl_to_tokens_int {
(signed, $t:ty, $tag:expr) => (
impl ToTokens for $t {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
let val = if *self < 0 {
-self
} else {
*self
};
let lit = ast::LitKind::Int(val as u128, ast::LitIntType::Signed($tag));
let lit = P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprKind::Lit(dummy_spanned(lit)),
span: DUMMY_SP,
attrs: ThinVec::new(),
});
if *self >= 0 {
return lit.to_tokens(cx);
}
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprKind::Unary(ast::UnOp::Neg, lit),
span: DUMMY_SP,
attrs: ThinVec::new(),
}).to_tokens(cx)
}
}
);
(unsigned, $t:ty, $tag:expr) => (
impl ToTokens for $t {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
let lit = ast::LitKind::Int(*self as u128, ast::LitIntType::Unsigned($tag));
dummy_spanned(lit).to_tokens(cx)
}
}
);
}
impl_to_tokens_int! { signed, isize, ast::IntTy::Isize }
impl_to_tokens_int! { signed, i8, ast::IntTy::I8 }
impl_to_tokens_int! { signed, i16, ast::IntTy::I16 }
impl_to_tokens_int! { signed, i32, ast::IntTy::I32 }
impl_to_tokens_int! { signed, i64, ast::IntTy::I64 }
impl_to_tokens_int! { unsigned, usize, ast::UintTy::Usize }
impl_to_tokens_int! { unsigned, u8, ast::UintTy::U8 }
impl_to_tokens_int! { unsigned, u16, ast::UintTy::U16 }
impl_to_tokens_int! { unsigned, u32, ast::UintTy::U32 }
impl_to_tokens_int! { unsigned, u64, ast::UintTy::U64 }
pub trait ExtParseUtils {
fn parse_item(&self, s: String) -> P<ast::Item>;
fn parse_expr(&self, s: String) -> P<ast::Expr>;
fn parse_stmt(&self, s: String) -> ast::Stmt;
fn parse_tts(&self, s: String) -> Vec<TokenTree>;
}
impl<'a> ExtParseUtils for ExtCtxt<'a> {
fn parse_item(&self, s: String) -> P<ast::Item> {
panictry!(parse::parse_item_from_source_str(
FileName::quote_expansion_source_code(&s),
s,
self.parse_sess())).expect("parse error")
}
fn parse_stmt(&self, s: String) -> ast::Stmt {
panictry!(parse::parse_stmt_from_source_str(
FileName::quote_expansion_source_code(&s),
s,
self.parse_sess())).expect("parse error")
}
fn parse_expr(&self, s: String) -> P<ast::Expr> {
panictry!(parse::parse_expr_from_source_str(
FileName::quote_expansion_source_code(&s),
s,
self.parse_sess()))
}
fn parse_tts(&self, s: String) -> Vec<TokenTree> {
let source_name = FileName::quote_expansion_source_code(&s);
parse::parse_stream_from_source_str(source_name, s, self.parse_sess(), None)
.into_trees().collect()
}
}
}
// Replaces `Token::OpenDelim .. Token::CloseDelim` with `TokenTree::Delimited(..)`.
pub fn unflatten(tts: Vec<TokenTree>) -> Vec<TokenTree> {
let mut results = Vec::new();
let mut result = Vec::new();
let mut open_span = DUMMY_SP;
for tree in tts {
match tree {
TokenTree::Token(span, token::OpenDelim(..)) => {
open_span = span;
results.push(::std::mem::replace(&mut result, Vec::new()));
}
TokenTree::Token(span, token::CloseDelim(delim)) => {
let delim_span = DelimSpan::from_pair(open_span, span);
let tree = TokenTree::Delimited(
delim_span,
delim,
result.into_iter().map(TokenStream::from).collect::<TokenStream>().into(),
);
result = results.pop().unwrap();
result.push(tree);
}
tree => result.push(tree),
}
}
result
}
// These panicking parsing functions are used by the quote_*!() syntax extensions,
// but shouldn't be used otherwise.
pub fn parse_expr_panic(parser: &mut Parser) -> P<Expr> {
panictry!(parser.parse_expr())
}
pub fn parse_item_panic(parser: &mut Parser) -> Option<P<Item>> {
panictry!(parser.parse_item())
}
pub fn parse_pat_panic(parser: &mut Parser) -> P<Pat> {
panictry!(parser.parse_pat(None))
}
pub fn parse_arm_panic(parser: &mut Parser) -> Arm {
panictry!(parser.parse_arm())
}
pub fn parse_ty_panic(parser: &mut Parser) -> P<Ty> {
panictry!(parser.parse_ty())
}
pub fn parse_stmt_panic(parser: &mut Parser) -> Option<Stmt> {
panictry!(parser.parse_stmt())
}
pub fn parse_attribute_panic(parser: &mut Parser, permit_inner: bool) -> ast::Attribute {
panictry!(parser.parse_attribute(permit_inner))
}
pub fn parse_arg_panic(parser: &mut Parser) -> Arg {
panictry!(parser.parse_arg())
}
pub fn parse_block_panic(parser: &mut Parser) -> P<Block> {
panictry!(parser.parse_block())
}
pub fn parse_meta_item_panic(parser: &mut Parser) -> ast::MetaItem {
panictry!(parser.parse_meta_item())
}
pub fn parse_path_panic(parser: &mut Parser, mode: PathStyle) -> ast::Path {
panictry!(parser.parse_path(mode))
}
pub fn expand_quote_tokens<'cx>(cx: &'cx mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'cx> {
let (cx_expr, expr) = expand_tts(cx, sp, tts);
let expanded = expand_wrapper(cx, sp, cx_expr, expr, &[&["syntax", "ext", "quote", "rt"]]);
base::MacEager::expr(expanded)
}
pub fn expand_quote_expr<'cx>(cx: &'cx mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'cx> {
let expanded = expand_parse_call(cx, sp, "parse_expr_panic", vec![], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_item<'cx>(cx: &'cx mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'cx> {
let expanded = expand_parse_call(cx, sp, "parse_item_panic", vec![], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_pat<'cx>(cx: &'cx mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'cx> {
let expanded = expand_parse_call(cx, sp, "parse_pat_panic", vec![], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_arm(cx: &mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'static> {
let expanded = expand_parse_call(cx, sp, "parse_arm_panic", vec![], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_ty(cx: &mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'static> {
let expanded = expand_parse_call(cx, sp, "parse_ty_panic", vec![], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_stmt(cx: &mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'static> {
let expanded = expand_parse_call(cx, sp, "parse_stmt_panic", vec![], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_attr(cx: &mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'static> {
let expanded = expand_parse_call(cx, sp, "parse_attribute_panic",
vec![cx.expr_bool(sp, true)], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_arg(cx: &mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'static> {
let expanded = expand_parse_call(cx, sp, "parse_arg_panic", vec![], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_block(cx: &mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'static> {
let expanded = expand_parse_call(cx, sp, "parse_block_panic", vec![], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_meta_item(cx: &mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'static> {
let expanded = expand_parse_call(cx, sp, "parse_meta_item_panic", vec![], tts);
base::MacEager::expr(expanded)
}
pub fn expand_quote_path(cx: &mut ExtCtxt,
sp: Span,
tts: &[TokenTree])
-> Box<dyn base::MacResult+'static> {
let mode = mk_parser_path(cx, sp, &["PathStyle", "Type"]);
let expanded = expand_parse_call(cx, sp, "parse_path_panic", vec![mode], tts);
base::MacEager::expr(expanded)
}
fn ids_ext(strs: Vec<String>) -> Vec<ast::Ident> {
strs.iter().map(|s| ast::Ident::from_str(s)).collect()
}
fn id_ext(s: &str) -> ast::Ident {
ast::Ident::from_str(s)
}
// Lift an ident to the expr that evaluates to that ident.
fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
let e_str = cx.expr_str(sp, ident.name);
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("ident_of"),
vec![e_str])
}
// Lift a name to the expr that evaluates to that name
fn mk_name(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> P<ast::Expr> {
let e_str = cx.expr_str(sp, ident.name);
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("name_of"),
vec![e_str])
}
fn mk_tt_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
let idents = vec![id_ext("syntax"), id_ext("tokenstream"), id_ext("TokenTree"), id_ext(name)];
cx.expr_path(cx.path_global(sp, idents))
}
fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
let idents = vec![id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name)];
cx.expr_path(cx.path_global(sp, idents))
}
fn mk_parser_path(cx: &ExtCtxt, sp: Span, names: &[&str]) -> P<ast::Expr> {
let mut idents = vec![id_ext("syntax"), id_ext("parse"), id_ext("parser")];
idents.extend(names.iter().cloned().map(id_ext));
cx.expr_path(cx.path_global(sp, idents))
}
fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOpToken) -> P<ast::Expr> {
let name = match bop {
token::Plus => "Plus",
token::Minus => "Minus",
token::Star => "Star",
token::Slash => "Slash",
token::Percent => "Percent",
token::Caret => "Caret",
token::And => "And",
token::Or => "Or",
token::Shl => "Shl",
token::Shr => "Shr"
};
mk_token_path(cx, sp, name)
}
fn mk_delim(cx: &ExtCtxt, sp: Span, delim: token::DelimToken) -> P<ast::Expr> {
let name = match delim {
token::Paren => "Paren",
token::Bracket => "Bracket",
token::Brace => "Brace",
token::NoDelim => "NoDelim",
};
mk_token_path(cx, sp, name)
}
#[allow(non_upper_case_globals)]
fn expr_mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> {
macro_rules! mk_lit {
($name: expr, $suffix: expr, $content: expr $(, $count: expr)*) => {{
let name = mk_name(cx, sp, ast::Ident::with_empty_ctxt($content));
let inner = cx.expr_call(sp, mk_token_path(cx, sp, $name), vec![
name $(, cx.expr_u16(sp, $count))*
]);
let suffix = match $suffix {
Some(name) => cx.expr_some(sp, mk_name(cx, sp, ast::Ident::with_empty_ctxt(name))),
None => cx.expr_none(sp)
};
cx.expr_call(sp, mk_token_path(cx, sp, "Literal"), vec![inner, suffix])
}}
}
let name = match *tok {
token::BinOp(binop) => {
return cx.expr_call(sp, mk_token_path(cx, sp, "BinOp"), vec![mk_binop(cx, sp, binop)]);
}
token::BinOpEq(binop) => {
return cx.expr_call(sp, mk_token_path(cx, sp, "BinOpEq"),
vec![mk_binop(cx, sp, binop)]);
}
token::OpenDelim(delim) => {
return cx.expr_call(sp, mk_token_path(cx, sp, "OpenDelim"),
vec![mk_delim(cx, sp, delim)]);
}
token::CloseDelim(delim) => {
return cx.expr_call(sp, mk_token_path(cx, sp, "CloseDelim"),
vec![mk_delim(cx, sp, delim)]);
}
token::Literal(token::Byte(i), suf) => return mk_lit!("Byte", suf, i),
token::Literal(token::Char(i), suf) => return mk_lit!("Char", suf, i),
token::Literal(token::Err(_i), _suf) => return cx.expr(sp, ast::ExprKind::Err),
token::Literal(token::Integer(i), suf) => return mk_lit!("Integer", suf, i),
token::Literal(token::Float(i), suf) => return mk_lit!("Float", suf, i),
token::Literal(token::Str_(i), suf) => return mk_lit!("Str_", suf, i),
token::Literal(token::StrRaw(i, n), suf) => return mk_lit!("StrRaw", suf, i, n),
token::Literal(token::ByteStr(i), suf) => return mk_lit!("ByteStr", suf, i),
token::Literal(token::ByteStrRaw(i, n), suf) => return mk_lit!("ByteStrRaw", suf, i, n),
token::Ident(ident, is_raw) => {
return cx.expr_call(sp,
mk_token_path(cx, sp, "Ident"),
vec![mk_ident(cx, sp, ident), cx.expr_bool(sp, is_raw)]);
}
token::Lifetime(ident) => {
return cx.expr_call(sp,
mk_token_path(cx, sp, "Lifetime"),
vec![mk_ident(cx, sp, ident)]);
}
token::DocComment(ident) => {
return cx.expr_call(sp,
mk_token_path(cx, sp, "DocComment"),
vec![mk_name(cx, sp, ast::Ident::with_empty_ctxt(ident))]);
}
token::Interpolated(_) => {
cx.span_err(sp, "quote! with interpolated token");
// Use dummy name.
"Interpolated"
}
token::Eq => "Eq",
token::Lt => "Lt",
token::Le => "Le",
token::EqEq => "EqEq",
token::Ne => "Ne",
token::Ge => "Ge",
token::Gt => "Gt",
token::AndAnd => "AndAnd",
token::OrOr => "OrOr",
token::Not => "Not",
token::Tilde => "Tilde",
token::At => "At",
token::Dot => "Dot",
token::DotDot => "DotDot",
token::DotDotDot => "DotDotDot",
token::DotDotEq => "DotDotEq",
token::Comma => "Comma",
token::Semi => "Semi",
token::Colon => "Colon",
token::ModSep => "ModSep",
token::RArrow => "RArrow",
token::LArrow => "LArrow",
token::FatArrow => "FatArrow",
token::Pound => "Pound",
token::Dollar => "Dollar",
token::Question => "Question",
token::SingleQuote => "SingleQuote",
token::Eof => "Eof",
token::Whitespace | token::Comment | token::Shebang(_) => {
panic!("unhandled token in quote!");
}
};
mk_token_path(cx, sp, name)
}
fn statements_mk_tt(cx: &ExtCtxt, tt: &TokenTree, quoted: bool) -> Vec<ast::Stmt> {
match *tt {
TokenTree::Token(sp, token::Ident(ident, _)) if quoted => {
// tt.extend($ident.to_tokens(ext_cx))
let e_to_toks =
cx.expr_method_call(sp,
cx.expr_ident(sp, ident),
id_ext("to_tokens"),
vec![cx.expr_ident(sp, id_ext("ext_cx"))]);
let e_to_toks =
cx.expr_method_call(sp, e_to_toks, id_ext("into_iter"), vec![]);
let e_push =
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("tt")),
id_ext("extend"),
vec![e_to_toks]);
vec![cx.stmt_expr(e_push)]
}
TokenTree::Token(sp, ref tok) => {
let e_sp = cx.expr_ident(sp, id_ext("_sp"));
let e_tok = cx.expr_call(sp,
mk_tt_path(cx, sp, "Token"),
vec![e_sp, expr_mk_token(cx, sp, tok)]);
let e_push =
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("tt")),
id_ext("push"),
vec![e_tok]);
vec![cx.stmt_expr(e_push)]
},
TokenTree::Delimited(span, delim, ref tts) => {
let mut stmts = statements_mk_tt(cx, &TokenTree::open_tt(span.open, delim), false);
stmts.extend(statements_mk_tts(cx, tts.clone()));
stmts.extend(statements_mk_tt(cx, &TokenTree::close_tt(span.close, delim), false));
stmts
}
}
}
fn parse_arguments_to_quote(cx: &ExtCtxt, tts: &[TokenTree])
-> (P<ast::Expr>, Vec<TokenTree>) {
let mut p = cx.new_parser_from_tts(tts);
let cx_expr = panictry!(p.parse_expr());
if !p.eat(&token::Comma) {
let _ = p.diagnostic().fatal("expected token `,`");
}
let tts = panictry!(p.parse_all_token_trees());
p.abort_if_errors();
(cx_expr, tts)
}
fn mk_stmts_let(cx: &ExtCtxt, sp: Span) -> Vec<ast::Stmt> {
// We also bind a single value, sp, to ext_cx.call_site()
//
// This causes every span in a token-tree quote to be attributed to the
// call site of the extension using the quote. We can't really do much
// better since the source of the quote may well be in a library that
// was not even parsed by this compilation run, that the user has no
// source code for (eg. in libsyntax, which they're just _using_).
//
// The old quasiquoter had an elaborate mechanism for denoting input
// file locations from which quotes originated; unfortunately this
// relied on feeding the source string of the quote back into the
// compiler (which we don't really want to do) and, in any case, only
// pushed the problem a very small step further back: an error
// resulting from a parse of the resulting quote is still attributed to
// the site the string literal occurred, which was in a source file
// _other_ than the one the user has control over. For example, an
// error in a quote from the protocol compiler, invoked in user code
// using macro_rules! for example, will be attributed to the macro_rules.rs
// file in libsyntax, which the user might not even have source to (unless
// they happen to have a compiler on hand). Over all, the phase distinction
// just makes quotes "hard to attribute". Possibly this could be fixed
// by recreating some of the original qq machinery in the tt regime
// (pushing fake SourceFiles onto the parser to account for original sites
// of quotes, for example) but at this point it seems not likely to be
// worth the hassle.
let e_sp = cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("call_site"),
Vec::new());
let stmt_let_sp = cx.stmt_let(sp, false,
id_ext("_sp"),
e_sp);
let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp));
vec![stmt_let_sp, stmt_let_tt]
}
fn statements_mk_tts(cx: &ExtCtxt, tts: TokenStream) -> Vec<ast::Stmt> {
let mut ss = Vec::new();
let mut quoted = false;
for tt in tts.into_trees() {
quoted = match tt {
TokenTree::Token(_, token::Dollar) if !quoted => true,
_ => {
ss.extend(statements_mk_tt(cx, &tt, quoted));
false
}
}
}
ss
}
fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[TokenTree]) -> (P<ast::Expr>, P<ast::Expr>) {
let (cx_expr, tts) = parse_arguments_to_quote(cx, tts);
let mut vector = mk_stmts_let(cx, sp);
vector.extend(statements_mk_tts(cx, tts.iter().cloned().collect()));
vector.push(cx.stmt_expr(cx.expr_ident(sp, id_ext("tt"))));
let block = cx.expr_block(cx.block(sp, vector));
let unflatten = vec![id_ext("syntax"), id_ext("ext"), id_ext("quote"), id_ext("unflatten")];
(cx_expr, cx.expr_call_global(sp, unflatten, vec![block]))
}
fn expand_wrapper(cx: &ExtCtxt,
sp: Span,
cx_expr: P<ast::Expr>,
expr: P<ast::Expr>,
imports: &[&[&str]]) -> P<ast::Expr> {
// Explicitly borrow to avoid moving from the invoker (#16992)
let cx_expr_borrow = cx.expr_addr_of(sp, cx.expr_deref(sp, cx_expr));
let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr_borrow);
let mut stmts = imports.iter().map(|path| {
// make item: `use ...;`
let path = path.iter().map(|s| s.to_string()).collect();
let use_item = cx.item_use_glob(
sp,
respan(sp.shrink_to_lo(), ast::VisibilityKind::Inherited),
ids_ext(path),
);
cx.stmt_item(sp, use_item)
}).chain(Some(stmt_let_ext_cx)).collect::<Vec<_>>();
stmts.push(cx.stmt_expr(expr));
cx.expr_block(cx.block(sp, stmts))
}
fn expand_parse_call(cx: &ExtCtxt,
sp: Span,
parse_method: &str,
arg_exprs: Vec<P<ast::Expr>> ,
tts: &[TokenTree]) -> P<ast::Expr> {
let (cx_expr, tts_expr) = expand_tts(cx, sp, tts);
let parse_sess_call = || cx.expr_method_call(
sp, cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("parse_sess"), Vec::new());
let new_parser_call =
cx.expr_call(sp,
cx.expr_ident(sp, id_ext("new_parser_from_tts")),
vec![parse_sess_call(), tts_expr]);
let path = vec![id_ext("syntax"), id_ext("ext"), id_ext("quote"), id_ext(parse_method)];
let mut args = vec![cx.expr_mut_addr_of(sp, new_parser_call)];
args.extend(arg_exprs);
let expr = cx.expr_call_global(sp, path, args);
if parse_method == "parse_attribute" {
expand_wrapper(cx, sp, cx_expr, expr, &[&["syntax", "ext", "quote", "rt"],
&["syntax", "parse", "attr"]])
} else {
expand_wrapper(cx, sp, cx_expr, expr, &[&["syntax", "ext", "quote", "rt"]])
}
}

2
src/libsyntax/feature_gate.rs
View File

@ -124,7 +124,6 @@ declare_features! (
(active, link_llvm_intrinsics, "1.0.0", Some(29602), None),
(active, linkage, "1.0.0", Some(29603), None),
(active, quote, "1.0.0", Some(29601), None),
// rustc internal
(active, rustc_diagnostic_macros, "1.0.0", None, None),
@ -504,6 +503,7 @@ declare_features! (
// Paths of the form: `extern::foo::bar`
(removed, extern_in_paths, "1.33.0", Some(55600), None,
Some("subsumed by `::foo::bar` paths")),
(removed, quote, "1.0.0", Some(29601), None, None),
);
declare_features! (

1
src/libsyntax/lib.rs
View File

@ -174,7 +174,6 @@ pub mod ext {
pub mod derive;
pub mod expand;
pub mod placeholders;
pub mod quote;
pub mod source_util;
pub mod tt {

39
src/libsyntax/parse/mod.rs
View File

@ -8,7 +8,6 @@ use syntax_pos::{Span, SourceFile, FileName, MultiSpan};
use errors::{FatalError, Level, Handler, ColorConfig, Diagnostic, DiagnosticBuilder};
use feature_gate::UnstableFeatures;
use parse::parser::Parser;
use ptr::P;
use symbol::Symbol;
use tokenstream::{TokenStream, TokenTree};
use diagnostics::plugin::ErrorMap;
@ -135,25 +134,6 @@ pub fn parse_crate_attrs_from_source_str(name: FileName, source: String, sess: &
new_parser_from_source_str(sess, name, source).parse_inner_attributes()
}
crate fn parse_expr_from_source_str(name: FileName, source: String, sess: &ParseSess)
-> PResult<P<ast::Expr>> {
new_parser_from_source_str(sess, name, source).parse_expr()
}
/// Parses an item.
///
/// Returns `Ok(Some(item))` when successful, `Ok(None)` when no item was found, and `Err`
/// when a syntax error occurred.
crate fn parse_item_from_source_str(name: FileName, source: String, sess: &ParseSess)
-> PResult<Option<P<ast::Item>>> {
new_parser_from_source_str(sess, name, source).parse_item()
}
crate fn parse_stmt_from_source_str(name: FileName, source: String, sess: &ParseSess)
-> PResult<Option<ast::Stmt>> {
new_parser_from_source_str(sess, name, source).parse_stmt()
}
pub fn parse_stream_from_source_str(name: FileName, source: String, sess: &ParseSess,
override_span: Option<Span>)
-> TokenStream {
@ -781,13 +761,22 @@ mod tests {
use syntax_pos::{Span, BytePos, Pos, NO_EXPANSION};
use ast::{self, Ident, PatKind};
use attr::first_attr_value_str_by_name;
use parse;
use ptr::P;
use print::pprust::item_to_string;
use tokenstream::{DelimSpan, TokenTree};
use util::parser_testing::string_to_stream;
use util::parser_testing::{string_to_expr, string_to_item};
use with_globals;
/// Parses an item.
///
/// Returns `Ok(Some(item))` when successful, `Ok(None)` when no item was found, and `Err`
/// when a syntax error occurred.
fn parse_item_from_source_str(name: FileName, source: String, sess: &ParseSess)
-> PResult<Option<P<ast::Item>>> {
new_parser_from_source_str(sess, name, source).parse_item()
}
// produce a syntax_pos::span
fn sp(a: u32, b: u32) -> Span {
Span::new(BytePos(a), BytePos(b), NO_EXPANSION)
@ -1016,9 +1005,15 @@ mod tests {
#[test]
fn ttdelim_span() {
fn parse_expr_from_source_str(
name: FileName, source: String, sess: &ParseSess
) -> PResult<P<ast::Expr>> {
new_parser_from_source_str(sess, name, source).parse_expr()
}
with_globals(|| {
let sess = ParseSess::new(FilePathMapping::empty());
let expr = parse::parse_expr_from_source_str(PathBuf::from("foo").into(),
let expr = parse_expr_from_source_str(PathBuf::from("foo").into(),
"foo!( fn main() { body } )".to_string(), &sess).unwrap();
let tts: Vec<_> = match expr.node {

3
src/libsyntax/parse/parser.rs
View File

@ -1285,9 +1285,6 @@ impl<'a> Parser<'a> {
crate fn span_bug<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> ! {
self.sess.span_diagnostic.span_bug(sp, m)
}
crate fn abort_if_errors(&self) {
self.sess.span_diagnostic.abort_if_errors();
}
fn cancel(&self, err: &mut DiagnosticBuilder) {
self.sess.span_diagnostic.cancel(err)

2
src/libsyntax/util/parser_testing.rs
View File

@ -25,7 +25,7 @@ fn with_error_checking_parse<'a, T, F>(s: String, ps: &'a ParseSess, f: F) -> T
{
let mut p = string_to_parser(&ps, s);
let x = panictry!(f(&mut p));
p.abort_if_errors();
p.sess.span_diagnostic.abort_if_errors();
x
}

22
src/libsyntax_ext/lib.rs
View File

@ -11,7 +11,6 @@
#![feature(decl_macro)]
#![feature(nll)]
#![feature(str_escape)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![recursion_limit="256"]
@ -58,8 +57,7 @@ use syntax::ext::hygiene;
use syntax::symbol::Symbol;
pub fn register_builtins(resolver: &mut dyn syntax::ext::base::Resolver,
user_exts: Vec<NamedSyntaxExtension>,
enable_quotes: bool) {
user_exts: Vec<NamedSyntaxExtension>) {
deriving::register_builtin_derives(resolver);
let mut register = |name, ext| {
@ -81,24 +79,6 @@ pub fn register_builtins(resolver: &mut dyn syntax::ext::base::Resolver,
)* }
}
if enable_quotes {
use syntax::ext::quote::*;
register! {
quote_tokens: expand_quote_tokens,
quote_expr: expand_quote_expr,
quote_ty: expand_quote_ty,
quote_item: expand_quote_item,
quote_pat: expand_quote_pat,
quote_arm: expand_quote_arm,
quote_stmt: expand_quote_stmt,
quote_attr: expand_quote_attr,
quote_arg: expand_quote_arg,
quote_block: expand_quote_block,
quote_meta_item: expand_quote_meta_item,
quote_path: expand_quote_path,
}
}
use syntax::ext::source_util::*;
register! {
line: expand_line,

35
src/test/run-fail-fulldeps/qquote.rs
View File

@ -1,35 +0,0 @@
// ignore-cross-compile
// error-pattern:expected expression, found statement (`let`)
#![feature(quote, rustc_private)]
extern crate syntax;
extern crate syntax_pos;
use syntax::ast;
use syntax::source_map;
use syntax::print::pprust;
use syntax::symbol::Symbol;
use syntax_pos::DUMMY_SP;
fn main() {
syntax::with_globals(|| run());
}
fn run() {
let ps = syntax::parse::ParseSess::new(source_map::FilePathMapping::empty());
let mut resolver = syntax::ext::base::DummyResolver;
let mut cx = syntax::ext::base::ExtCtxt::new(
&ps,
syntax::ext::expand::ExpansionConfig::default("qquote".to_string()),
&mut resolver);
let cx = &mut cx;
println!("{}", pprust::expr_to_string(&*quote_expr!(&cx, 23)));
assert_eq!(pprust::expr_to_string(&*quote_expr!(&cx, 23)), "23");
let expr = quote_expr!(&cx, let x isize = 20;);
println!("{}", pprust::expr_to_string(&*expr));
assert_eq!(pprust::expr_to_string(&*expr), "let x isize = 20;");
}

29
src/test/run-pass-fulldeps/auxiliary/issue-16723.rs
View File

@ -1,29 +0,0 @@
// force-host
#![feature(plugin_registrar, quote, rustc_private)]
#![crate_type = "dylib"]
extern crate syntax;
extern crate rustc;
extern crate rustc_data_structures;
extern crate rustc_plugin;
#[macro_use] extern crate smallvec;
extern crate syntax_pos;
use smallvec::SmallVec;
use syntax::ext::base::{ExtCtxt, MacResult, MacEager};
use syntax::tokenstream;
use rustc_plugin::Registry;
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_macro("multiple_items", expand)
}
fn expand(cx: &mut ExtCtxt, _: syntax_pos::Span, _: &[tokenstream::TokenTree])
-> Box<MacResult+'static> {
MacEager::items(smallvec![
quote_item!(cx, struct Struct1;).unwrap(),
quote_item!(cx, struct Struct2;).unwrap()
])
}

223
src/test/run-pass-fulldeps/auxiliary/macro_crate_test.rs
View File

@ -1,209 +1,34 @@
// force-host
// no-prefer-dynamic
#![feature(plugin_registrar, quote, rustc_private)]
#![crate_type = "proc-macro"]
#![feature(rustc_private)]
extern crate syntax;
extern crate rustc;
extern crate rustc_plugin;
extern crate syntax_pos;
extern crate proc_macro;
use syntax::ast::{self, Item, MetaItem, ItemKind};
use syntax::source_map::DUMMY_SP;
use syntax::ext::base::*;
use syntax::ext::quote::rt::ToTokens;
use syntax::parse::{self, token};
use syntax::ptr::P;
use syntax::symbol::Symbol;
use syntax::tokenstream::TokenTree;
use syntax_pos::Span;
use rustc_plugin::Registry;
use proc_macro::{TokenTree, TokenStream};
#[macro_export]
macro_rules! exported_macro { () => (2) }
macro_rules! unexported_macro { () => (3) }
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_macro("make_a_1", expand_make_a_1);
reg.register_macro("identity", expand_identity);
reg.register_syntax_extension(
Symbol::intern("rustc_into_multi_foo"),
MultiModifier(Box::new(expand_into_foo_multi)));
reg.register_syntax_extension(
Symbol::intern("rustc_duplicate"),
MultiDecorator(Box::new(expand_duplicate)));
reg.register_syntax_extension(
Symbol::intern("rustc_caller"),
MultiDecorator(Box::new(expand_caller)));
#[proc_macro_attribute]
pub fn rustc_duplicate(attr: TokenStream, item: TokenStream) -> TokenStream {
let mut new_name = Some(attr.into_iter().nth(0).unwrap());
let mut encountered_idents = 0;
let input = item.to_string();
let ret = item.into_iter().map(move |token| match token {
TokenTree::Ident(_) if encountered_idents == 1 => {
encountered_idents += 1;
new_name.take().unwrap()
}
TokenTree::Ident(_) => {
encountered_idents += 1;
token
}
_ => token
}).collect::<TokenStream>();
let mut input_again = input.parse::<TokenStream>().unwrap();
input_again.extend(ret);
input_again
}
fn expand_make_a_1(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree]) -> Box<MacResult + 'static> {
if !tts.is_empty() {
cx.span_fatal(sp, "make_a_1 takes no arguments");
}
MacEager::expr(quote_expr!(cx, 1))
}
// See Issue #15750
fn expand_identity(cx: &mut ExtCtxt, _span: Span, tts: &[TokenTree]) -> Box<MacResult + 'static> {
// Parse an expression and emit it unchanged.
let mut parser = parse::new_parser_from_tts(cx.parse_sess(), tts.to_vec());
let expr = parser.parse_expr().unwrap();
MacEager::expr(quote_expr!(&mut *cx, $expr))
}
fn expand_into_foo_multi(cx: &mut ExtCtxt,
_sp: Span,
_attr: &MetaItem,
it: Annotatable)
-> Vec<Annotatable> {
match it {
Annotatable::Item(it) => vec![
Annotatable::Item(P(Item {
attrs: it.attrs.clone(),
..(*quote_item!(cx, enum Foo2 { Bar2, Baz2 }).unwrap()).clone()
})),
Annotatable::Item(quote_item!(cx, enum Foo3 { Bar }).unwrap()),
Annotatable::Item(quote_item!(cx, #[cfg(any())] fn foo2() {}).unwrap()),
],
Annotatable::ImplItem(_it) => vec![
quote_item!(cx, impl X { fn foo(&self) -> i32 { 42 } }).unwrap().and_then(|i| {
match i.node {
ItemKind::Impl(.., mut items) => {
Annotatable::ImplItem(P(items.pop().expect("impl method not found")))
}
_ => unreachable!("impl parsed to something other than impl")
}
})
],
Annotatable::TraitItem(_it) => vec![
quote_item!(cx, trait X { fn foo(&self) -> i32 { 0 } }).unwrap().and_then(|i| {
match i.node {
ItemKind::Trait(.., mut items) => {
Annotatable::TraitItem(P(items.pop().expect("trait method not found")))
}
_ => unreachable!("trait parsed to something other than trait")
}
})
],
// covered in proc_macro/macros-in-extern.rs
Annotatable::ForeignItem(..) => unimplemented!(),
// covered in proc_macro/attr-stmt-expr.rs
Annotatable::Stmt(_) | Annotatable::Expr(_) => panic!("expected item"),
}
}
// Create a duplicate of the annotatable, based on the MetaItem
fn expand_duplicate(cx: &mut ExtCtxt,
_sp: Span,
mi: &MetaItem,
it: &Annotatable,
push: &mut FnMut(Annotatable)) {
let copy_name = match mi.node {
ast::MetaItemKind::List(ref xs) => {
if let Some(word) = xs[0].word() {
word.ident.segments.last().unwrap().ident
} else {
cx.span_err(mi.span, "Expected word");
return;
}
}
_ => {
cx.span_err(mi.span, "Expected list");
return;
}
};
// Duplicate the item but replace its ident by the MetaItem
match it.clone() {
Annotatable::Item(it) => {
let mut new_it = (*it).clone();
new_it.attrs.clear();
new_it.ident = copy_name;
push(Annotatable::Item(P(new_it)));
}
Annotatable::ImplItem(it) => {
let mut new_it = (*it).clone();
new_it.attrs.clear();
new_it.ident = copy_name;
push(Annotatable::ImplItem(P(new_it)));
}
Annotatable::TraitItem(tt) => {
let mut new_it = (*tt).clone();
new_it.attrs.clear();
new_it.ident = copy_name;
push(Annotatable::TraitItem(P(new_it)));
}
// covered in proc_macro/macros-in-extern.rs
Annotatable::ForeignItem(..) => unimplemented!(),
// covered in proc_macro/attr-stmt-expr.rs
Annotatable::Stmt(_) | Annotatable::Expr(_) => panic!("expected item")
}
}
pub fn token_separate<T: ToTokens>(ecx: &ExtCtxt, things: &[T],
token: token::Token) -> Vec<TokenTree> {
let mut output: Vec<TokenTree> = vec![];
for (i, thing) in things.iter().enumerate() {
output.extend(thing.to_tokens(ecx));
if i < things.len() - 1 {
output.push(TokenTree::Token(DUMMY_SP, token.clone()));
}
}
output
}
fn expand_caller(cx: &mut ExtCtxt,
sp: Span,
mi: &MetaItem,
it: &Annotatable,
push: &mut FnMut(Annotatable)) {
let (orig_fn_name, ret_type) = match *it {
Annotatable::Item(ref item) => match item.node {
ItemKind::Fn(ref decl, ..) => {
(item.ident, &decl.output)
}
_ => cx.span_fatal(item.span, "Only functions with return types can be annotated.")
},
_ => cx.span_fatal(sp, "Only functions can be annotated.")
};
let (caller_name, arguments) = if let Some(list) = mi.meta_item_list() {
if list.len() < 2 {
cx.span_fatal(mi.span(), "Need a function name and at least one parameter.");
}
let fn_name = match list[0].name() {
Some(name) => ast::Ident::with_empty_ctxt(name),
None => cx.span_fatal(list[0].span(), "First parameter must be an ident.")
};
(fn_name, &list[1..])
} else {
cx.span_fatal(mi.span, "Expected list.");
};
let literals: Vec<ast::Lit> = arguments.iter().map(|arg| {
if let Some(lit) = arg.literal() {
lit.clone()
} else {
cx.span_fatal(arg.span(), "Expected literal.");
}
}).collect();
let arguments = token_separate(cx, literals.as_slice(), token::Comma);
if let ast::FunctionRetTy::Ty(ref rt) = *ret_type {
push(Annotatable::Item(quote_item!(cx,
fn $caller_name() -> $rt {
$orig_fn_name($arguments)
}).unwrap()))
} else {
push(Annotatable::Item(quote_item!(cx,
fn $caller_name() {
$orig_fn_name($arguments)
}).unwrap()))
}
}
pub fn foo() {}

13
src/test/run-pass-fulldeps/auxiliary/plugin_with_plugin_lib.rs
View File

@ -1,13 +0,0 @@
// force-host
#![feature(plugin_registrar, rustc_private)]
#![deny(plugin_as_library)] // should have no effect in a plugin crate
extern crate macro_crate_test;
extern crate rustc;
extern crate rustc_plugin;
use rustc_plugin::Registry;
#[plugin_registrar]
pub fn plugin_registrar(_: &mut Registry) { }

82
src/test/run-pass-fulldeps/auxiliary/procedural_mbe_matching.rs
View File

@ -1,82 +0,0 @@
// force-host
#![crate_type="dylib"]
#![feature(plugin_registrar, quote, rustc_private)]
extern crate syntax;
extern crate syntax_pos;
extern crate rustc;
extern crate rustc_plugin;
use syntax::feature_gate::Features;
use syntax::parse::token::{NtExpr, NtPat};
use syntax::ast::{Ident, Pat, NodeId};
use syntax::tokenstream::{TokenTree};
use syntax::ext::base::{ExtCtxt, MacResult, MacEager};
use syntax::ext::build::AstBuilder;
use syntax::ext::tt::quoted;
use syntax::ext::tt::macro_parser::{MatchedSeq, MatchedNonterminal};
use syntax::ext::tt::macro_parser::{Success, Failure, Error};
use syntax::ext::tt::macro_parser::parse_failure_msg;
use syntax::ptr::P;
use syntax_pos::{Span, edition::Edition};
use rustc_plugin::Registry;
fn expand_mbe_matches(cx: &mut ExtCtxt, _: Span, args: &[TokenTree])
-> Box<MacResult + 'static> {
let mbe_matcher = quote_tokens!(cx, $$matched:expr, $$($$pat:pat)|+);
let mbe_matcher = quoted::parse(mbe_matcher.into_iter().collect(),
true,
cx.parse_sess,
&Features::new(),
&[],
Edition::Edition2015,
// not used...
NodeId::from_u32(0));
let map = match TokenTree::parse(cx, &mbe_matcher, args.iter().cloned().collect()) {
Success(map) => map,
Failure(_, tok, msg) => {
panic!("expected Success, but got Failure: {} - {}", parse_failure_msg(tok), msg);
}
Error(_, s) => {
panic!("expected Success, but got Error: {}", s);
}
};
let matched_nt = match *map[&Ident::from_str("matched")] {
MatchedNonterminal(ref nt) => nt.clone(),
_ => unreachable!(),
};
let mac_expr = match (&*matched_nt, &*map[&Ident::from_str("pat")]) {
(&NtExpr(ref matched_expr), &MatchedSeq(ref pats, seq_sp)) => {
let pats: Vec<P<Pat>> = pats.iter().map(|pat_nt| {
match *pat_nt {
MatchedNonterminal(ref nt) => match **nt {
NtPat(ref pat) => pat.clone(),
_ => unreachable!(),
},
_ => unreachable!(),
}
}).collect();
let span = seq_sp.entire();
let arm = cx.arm(span, pats, cx.expr_bool(span, true));
quote_expr!(cx,
match $matched_expr {
$arm
_ => false
}
)
}
_ => unreachable!()
};
MacEager::expr(mac_expr)
}
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_macro("matches", expand_mbe_matches);
}

27
src/test/run-pass-fulldeps/auxiliary/syntax_extension_with_dll_deps_2.rs
View File

@ -1,27 +0,0 @@
// force-host
#![crate_type = "dylib"]
#![feature(plugin_registrar, quote, rustc_private)]
extern crate syntax_extension_with_dll_deps_1 as other;
extern crate syntax;
extern crate syntax_pos;
extern crate rustc;
extern crate rustc_plugin;
use syntax::ast::{Item, MetaItem};
use syntax::ext::base::*;
use syntax::tokenstream::TokenTree;
use syntax_pos::Span;
use rustc_plugin::Registry;
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_macro("foo", expand_foo);
}
fn expand_foo(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
-> Box<MacResult+'static> {
let answer = other::the_answer();
MacEager::expr(quote_expr!(cx, $answer))
}

19
src/test/run-pass-fulldeps/issue-16723.rs
View File

@ -1,19 +0,0 @@
// ignore-stage1
// aux-build:issue-16723.rs
#![feature(plugin)]
#![plugin(issue_16723)]
multiple_items!();
impl Struct1 {
fn foo() {}
}
impl Struct2 {
fn foo() {}
}
fn main() {
Struct1::foo();
Struct2::foo();
println!("hallo");
}

15
src/test/run-pass-fulldeps/issue-16992.rs
View File

@ -1,15 +0,0 @@
// ignore-cross-compile
#![feature(quote, rustc_private)]
extern crate syntax;
use syntax::ext::base::ExtCtxt;
#[allow(dead_code)]
fn foobar(cx: &mut ExtCtxt) {
quote_expr!(cx, 1);
quote_expr!(cx, 2);
}
fn main() { }

22
src/test/run-pass-fulldeps/issue-18763-quote-token-tree.rs
View File

@ -1,22 +0,0 @@
#![allow(dead_code)]
#![allow(unused_imports)]
// ignore-cross-compile
#![feature(quote, rustc_private)]
extern crate syntax;
use syntax::ext::base::ExtCtxt;
fn syntax_extension(cx: &ExtCtxt) {
let _toks_1 = vec![quote_tokens!(cx, /** comment */ fn foo() {})];
let name = quote_tokens!(cx, bar);
let _toks_2 = vec![quote_item!(cx, static $name:isize = 2;)];
let _toks_4 = quote_tokens!(cx, $name:static $name:sizeof);
let _toks_3 = vec![quote_item!(cx,
/// comment
fn foo() { let $name:isize = 3; }
)];
}
fn main() {
}

16
src/test/run-pass-fulldeps/macro-crate-does-hygiene-work.rs
View File

@ -1,16 +0,0 @@
// aux-build:macro_crate_test.rs
// ignore-stage1
// Issue #15750: a macro that internally parses its input and then
// uses `quote_expr!` to rearrange it should be hygiene-preserving.
#![feature(plugin)]
#![plugin(macro_crate_test)]
fn main() {
let x = 3;
assert_eq!(3, identity!(x));
assert_eq!(6, identity!(x+x));
let x = 4;
assert_eq!(4, identity!(x));
}

50
src/test/run-pass-fulldeps/macro-crate-multi-decorator-literals.rs
View File

@ -1,50 +0,0 @@
#![allow(plugin_as_library)]
#![allow(unused_imports)]
// aux-build:macro_crate_test.rs
// ignore-stage1
#![feature(plugin, rustc_attrs)]
#![plugin(macro_crate_test)]
#[macro_use]
#[no_link]
extern crate macro_crate_test;
// The `caller(name, args...)` attribute emits a new nullary function named
// `name` that calls the annotated function with `args`. As an example, consider
// the following:
//
// #[caller(simple, 1, "hello", 3.14)]
// fn f(num: isize, string: &'static str, float: f32) -> (isize, &'static str, float) {
// (num, string, float)
// }
//
// This results in a function named `simple` that calls `f(1, "hello", 3.14)`.
// As a result, the expression `simple()` evaluates to `(1, "helllo", 3.14)`.
#[rustc_caller(simple, 1, "hello", 3.14)]
#[rustc_caller(simple1, 2, "bye", 6.28)]
#[rustc_caller(simple2, 3, "hi", 1.01)]
fn f(num: isize, string: &'static str, float: f32) -> (isize, &'static str, f32) {
(num, string, float)
}
#[rustc_caller(complex, true, 10)]
#[rustc_caller(complex1, false, 15)]
#[rustc_caller(complex2, true, 20)]
fn g(emit: bool, num: i32) -> Option<i32> {
match emit {
true => Some(num),
false => None
}
}
fn main() {
assert_eq!(simple(), (1, "hello", 3.14));
assert_eq!(simple1(), (2, "bye", 6.28));
assert_eq!(simple2(), (3, "hi", 1.01));
assert_eq!(complex(), Some(10));
assert_eq!(complex1(), None);
assert_eq!(complex2(), Some(20));
}

4
src/test/run-pass-fulldeps/macro-crate-multi-decorator.rs
View File

@ -5,11 +5,9 @@
// aux-build:macro_crate_test.rs
// ignore-stage1
#![feature(plugin, rustc_attrs)]
#![plugin(macro_crate_test)]
#![feature(rustc_attrs)]
#[macro_use]
#[no_link]
extern crate macro_crate_test;
// The duplicate macro will create a copy of the item with the given identifier.

46
src/test/run-pass-fulldeps/macro-crate.rs
View File

@ -1,46 +0,0 @@
#![allow(plugin_as_library)]
#![allow(dead_code)]
// aux-build:macro_crate_test.rs
// ignore-stage1
#![feature(plugin, rustc_attrs)]
#![plugin(macro_crate_test)]
#[macro_use] #[no_link]
extern crate macro_crate_test;
#[rustc_into_multi_foo]
#[derive(PartialEq, Clone, Debug)]
fn foo() -> AnotherFakeTypeThatHadBetterGoAway {}
// Check that the `#[into_multi_foo]`-generated `foo2` is configured away
fn foo2() {}
trait Qux {
#[rustc_into_multi_foo]
fn bar();
}
impl Qux for i32 {
#[rustc_into_multi_foo]
fn bar() {}
}
impl Qux for u8 {}
pub fn main() {
assert_eq!(1, make_a_1!());
assert_eq!(2, exported_macro!());
assert_eq!(Foo2::Bar2, Foo2::Bar2);
test(None::<Foo2>);
let _ = Foo3::Bar;
let x = 10i32;
assert_eq!(x.foo(), 42);
let x = 10u8;
assert_eq!(x.foo(), 0);
}
fn test<T: PartialEq+Clone>(_: Option<T>) {}

11
src/test/run-pass-fulldeps/mbe_matching_test_macro.rs
View File

@ -1,11 +0,0 @@
// aux-build:procedural_mbe_matching.rs
// ignore-stage1
#![feature(plugin)]
#![plugin(procedural_mbe_matching)]
pub fn main() {
assert_eq!(matches!(Some(123), None | Some(0)), false);
assert_eq!(matches!(Some(123), None | Some(123)), true);
assert_eq!(matches!(true, true), true);
}

16
src/test/run-pass-fulldeps/plugin-lib-ok-in-plugin.rs
View File

@ -1,16 +0,0 @@
// aux-build:macro_crate_test.rs
// aux-build:plugin_with_plugin_lib.rs
// ignore-stage1
// ignore-cross-compile
//
// macro_crate_test will not compile on a cross-compiled target because
// libsyntax is not compiled for it.
#![deny(plugin_as_library)]
#![feature(plugin)]
#![plugin(macro_crate_test)]
#![plugin(plugin_with_plugin_lib)]
fn main() {
assert_eq!(1, make_a_1!());
}

17
src/test/run-pass-fulldeps/plugin-plus-extern-crate.rs
View File

@ -1,17 +0,0 @@
// aux-build:macro_crate_test.rs
// ignore-stage1
// ignore-cross-compile
//
// macro_crate_test will not compile on a cross-compiled target because
// libsyntax is not compiled for it.
#![allow(plugin_as_library)]
#![feature(plugin)]
#![plugin(macro_crate_test)]
extern crate macro_crate_test;
fn main() {
assert_eq!(1, make_a_1!());
macro_crate_test::foo();
}

92
src/test/run-pass-fulldeps/qquote.rs
View File

@ -1,92 +0,0 @@
#![allow(unused_imports)]
// ignore-cross-compile
#![feature(quote, rustc_private)]
extern crate syntax;
extern crate syntax_pos;
use syntax::source_map::FilePathMapping;
use syntax::print::pprust::*;
use syntax::symbol::Symbol;
use syntax_pos::DUMMY_SP;
fn main() {
syntax::with_globals(|| run());
}
fn run() {
let ps = syntax::parse::ParseSess::new(FilePathMapping::empty());
let mut resolver = syntax::ext::base::DummyResolver;
let mut cx = syntax::ext::base::ExtCtxt::new(
&ps,
syntax::ext::expand::ExpansionConfig::default("qquote".to_string()),
&mut resolver);
let cx = &mut cx;
macro_rules! check {
($f: ident, $($e: expr),+; $expect: expr) => ({
$(assert_eq!($f(&$e), $expect);)+
});
}
let abc = quote_expr!(cx, 23);
check!(expr_to_string, abc, *quote_expr!(cx, $abc); "23");
let ty = quote_ty!(cx, isize);
check!(ty_to_string, ty, *quote_ty!(cx, $ty); "isize");
let item = quote_item!(cx, static x: $ty = 10;).unwrap();
check!(item_to_string, item, quote_item!(cx, $item).unwrap(); "static x: isize = 10;");
let twenty: u16 = 20;
let stmt = quote_stmt!(cx, let x = $twenty;).unwrap();
check!(stmt_to_string, stmt, quote_stmt!(cx, $stmt).unwrap(); "let x = 20u16;");
let pat = quote_pat!(cx, Some(_));
check!(pat_to_string, pat, *quote_pat!(cx, $pat); "Some(_)");
let expr = quote_expr!(cx, (x, y));
let arm = quote_arm!(cx, (ref x, ref y) => $expr,);
check!(arm_to_string, arm, quote_arm!(cx, $arm); " (ref x, ref y) => (x, y),");
let attr = quote_attr!(cx, #![cfg(foo = "bar")]);
check!(attribute_to_string, attr, quote_attr!(cx, $attr); r#"#![cfg(foo = "bar")]"#);
// quote_arg!
let arg = quote_arg!(cx, foo: i32);
check!(arg_to_string, arg, quote_arg!(cx, $arg); "foo: i32");
let function = quote_item!(cx, fn f($arg) { }).unwrap();
check!(item_to_string, function; "fn f(foo: i32) { }");
let args = vec![arg, quote_arg!(cx, bar: u32)];
let args = &args[..];
let function = quote_item!(cx, fn f($args) { }).unwrap();
check!(item_to_string, function; "fn f(foo: i32, bar: u32) { }");
// quote_block!
let block = quote_block!(cx, { $stmt let y = 40u32; });
check!(block_to_string, block, *quote_block!(cx, $block); "{ let x = 20u16; let y = 40u32; }");
let function = quote_item!(cx, fn f() $block).unwrap();
check!(item_to_string, function; "fn f() { let x = 20u16; let y = 40u32; }");
// quote_path!
let path = quote_path!(cx, ::syntax::ptr::P<MetaItem>);
check!(path_to_string, path, quote_path!(cx, $path); "::syntax::ptr::P<MetaItem>");
let ty = quote_ty!(cx, $path);
check!(ty_to_string, ty; "::syntax::ptr::P<MetaItem>");
// quote_meta_item!
let meta = quote_meta_item!(cx, cfg(foo = "bar"));
check!(meta_item_to_string, meta, quote_meta_item!(cx, $meta); r#"cfg(foo = "bar")"#);
let attr = quote_attr!(cx, #![$meta]);
check!(attribute_to_string, attr; r#"#![cfg(foo = "bar")]"#);
}

45
src/test/run-pass-fulldeps/quote-tokens.rs
View File

@ -1,45 +0,0 @@
#![allow(dead_code)]
#![allow(unused_variables)]
#![allow(unused_imports)]
// ignore-cross-compile
#![feature(quote, rustc_private)]
extern crate syntax;
use syntax::ext::base::ExtCtxt;
use syntax::ptr::P;
use syntax::parse::PResult;
fn syntax_extension(cx: &ExtCtxt) {
let e_toks : Vec<syntax::tokenstream::TokenTree> = quote_tokens!(cx, 1 + 2);
let p_toks : Vec<syntax::tokenstream::TokenTree> = quote_tokens!(cx, (x, 1 .. 4, *));
let a: P<syntax::ast::Expr> = quote_expr!(cx, 1 + 2);
let _b: Option<P<syntax::ast::Item>> = quote_item!(cx, static foo : isize = $e_toks; );
let _c: P<syntax::ast::Pat> = quote_pat!(cx, (x, 1 .. 4, *) );
let _d: Option<syntax::ast::Stmt> = quote_stmt!(cx, let x = $a; );
let _d: syntax::ast::Arm = quote_arm!(cx, (ref x, ref y) = (x, y) );
let _e: P<syntax::ast::Expr> = quote_expr!(cx, match foo { $p_toks => 10 } );
let _f: P<syntax::ast::Expr> = quote_expr!(cx, ());
let _g: P<syntax::ast::Expr> = quote_expr!(cx, true);
let _h: P<syntax::ast::Expr> = quote_expr!(cx, 'a');
let i: Option<P<syntax::ast::Item>> = quote_item!(cx, #[derive(Eq)] struct Foo; );
assert!(i.is_some());
let _l: P<syntax::ast::Ty> = quote_ty!(cx, &isize);
let _n: syntax::ast::Attribute = quote_attr!(cx, #![cfg(foo, bar = "baz")]);
let _o: Option<P<syntax::ast::Item>> = quote_item!(cx, fn foo<T: ?Sized>() {});
let stmts = vec![
quote_stmt!(cx, let x = 1;).unwrap(),
quote_stmt!(cx, let y = 2;).unwrap(),
];
let expr: P<syntax::ast::Expr> = quote_expr!(cx, x + y);
}
fn main() {
}

15
src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs
View File

@ -1,15 +0,0 @@
#![allow(dead_code)]
// ignore-cross-compile
#![feature(quote, rustc_private)]
#![deny(unused_variables)]
extern crate syntax;
use syntax::ext::base::ExtCtxt;
fn test(cx: &mut ExtCtxt) {
let foo = 10;
let _e = quote_expr!(cx, $foo);
}
pub fn main() { }

10
src/test/run-pass-fulldeps/syntax-extension-with-dll-deps.rs
View File

@ -1,10 +0,0 @@
// aux-build:syntax_extension_with_dll_deps_1.rs
// aux-build:syntax_extension_with_dll_deps_2.rs
// ignore-stage1
#![feature(plugin, rustc_private)]
#![plugin(syntax_extension_with_dll_deps_2)]
fn main() {
foo!();
}

149
src/test/ui-fulldeps/auxiliary/macro_crate_test.rs
View File

@ -1,149 +0,0 @@
// force-host
#![feature(plugin_registrar, quote, rustc_private)]
extern crate syntax;
extern crate syntax_pos;
extern crate rustc;
extern crate rustc_plugin;
use syntax::ast::{self, Item, MetaItem, ItemKind};
use syntax::ext::base::*;
use syntax::parse;
use syntax::ptr::P;
use syntax::symbol::Symbol;
use syntax::tokenstream::TokenTree;
use syntax_pos::Span;
use rustc_plugin::Registry;
#[macro_export]
macro_rules! exported_macro { () => (2) }
macro_rules! unexported_macro { () => (3) }
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_macro("make_a_1", expand_make_a_1);
reg.register_macro("identity", expand_identity);
reg.register_syntax_extension(
Symbol::intern("into_multi_foo"),
MultiModifier(Box::new(expand_into_foo_multi)));
reg.register_syntax_extension(
Symbol::intern("noop_attribute"),
MultiModifier(Box::new(expand_noop_attribute)));
reg.register_syntax_extension(
Symbol::intern("duplicate"),
MultiDecorator(Box::new(expand_duplicate)));
}
fn expand_make_a_1(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
-> Box<MacResult+'static> {
if !tts.is_empty() {
cx.span_fatal(sp, "make_a_1 takes no arguments");
}
MacEager::expr(quote_expr!(cx, 1))
}
// See Issue #15750
fn expand_identity(cx: &mut ExtCtxt, _span: Span, tts: &[TokenTree])
-> Box<MacResult+'static> {
// Parse an expression and emit it unchanged.
let mut parser = parse::new_parser_from_tts(cx.parse_sess(), tts.to_vec());
let expr = parser.parse_expr().unwrap();
MacEager::expr(quote_expr!(&mut *cx, $expr))
}
fn expand_into_foo_multi(cx: &mut ExtCtxt,
_sp: Span,
_attr: &MetaItem,
it: Annotatable) -> Annotatable {
match it {
Annotatable::Item(it) => {
Annotatable::Item(P(Item {
attrs: it.attrs.clone(),
..(*quote_item!(cx, enum Foo2 { Bar2, Baz2 }).unwrap()).clone()
}))
}
Annotatable::ImplItem(_) => {
quote_item!(cx, impl X { fn foo(&self) -> i32 { 42 } }).unwrap().and_then(|i| {
match i.node {
ItemKind::Impl(.., mut items) => {
Annotatable::ImplItem(P(items.pop().expect("impl method not found")))
}
_ => unreachable!("impl parsed to something other than impl")
}
})
}
Annotatable::TraitItem(_) => {
quote_item!(cx, trait X { fn foo(&self) -> i32 { 0 } }).unwrap().and_then(|i| {
match i.node {
ItemKind::Trait(.., mut items) => {
Annotatable::TraitItem(P(items.pop().expect("trait method not found")))
}
_ => unreachable!("trait parsed to something other than trait")
}
})
}
// covered in proc_macro/macros-in-extern.rs
Annotatable::ForeignItem(_) => unimplemented!(),
// covered in proc_macro/attr-stmt-expr.rs
Annotatable::Stmt(_) | Annotatable::Expr(_) => panic!("expected item")
}
}
fn expand_noop_attribute(_cx: &mut ExtCtxt,
_sp: Span,
_attr: &MetaItem,
it: Annotatable) -> Annotatable {
it
}
// Create a duplicate of the annotatable, based on the MetaItem
fn expand_duplicate(cx: &mut ExtCtxt,
_sp: Span,
mi: &MetaItem,
it: &Annotatable,
push: &mut FnMut(Annotatable))
{
let copy_name = match mi.node {
ast::MetaItemKind::List(ref xs) => {
if let Some(word) = xs[0].word() {
word.ident.segments.last().unwrap().ident
} else {
cx.span_err(mi.span, "Expected word");
return;
}
}
_ => {
cx.span_err(mi.span, "Expected list");
return;
}
};
// Duplicate the item but replace its ident by the MetaItem
match it.clone() {
Annotatable::Item(it) => {
let mut new_it = (*it).clone();
new_it.attrs.clear();
new_it.ident = copy_name;
push(Annotatable::Item(P(new_it)));
}
Annotatable::ImplItem(it) => {
let mut new_it = (*it).clone();
new_it.attrs.clear();
new_it.ident = copy_name;
push(Annotatable::ImplItem(P(new_it)));
}
Annotatable::TraitItem(tt) => {
let mut new_it = (*tt).clone();
new_it.attrs.clear();
new_it.ident = copy_name;
push(Annotatable::TraitItem(P(new_it)));
}
// covered in proc_macro/macros-in-extern.rs
Annotatable::ForeignItem(_) => unimplemented!(),
// covered in proc_macro/attr-stmt-expr.rs
Annotatable::Stmt(_) | Annotatable::Expr(_) => panic!("expected item")
}
}
pub fn foo() {}

4
src/test/ui-fulldeps/gated-plugin.rs
View File

@ -1,6 +1,6 @@
// aux-build:macro_crate_test.rs
// aux-build:attr_plugin_test.rs
#![plugin(macro_crate_test)]
#![plugin(attr_plugin_test)]
//~^ ERROR compiler plugins are experimental and possibly buggy
fn main() {}

2
src/test/ui-fulldeps/gated-plugin.stderr
View File

@ -1,7 +1,7 @@
error[E0658]: compiler plugins are experimental and possibly buggy (see issue #29597)
--> $DIR/gated-plugin.rs:3:1
|
LL | #![plugin(macro_crate_test)]
LL | #![plugin(attr_plugin_test)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: add #![feature(plugin)] to the crate attributes to enable

57
src/test/ui-fulldeps/gated-quote.rs
View File

@ -1,57 +0,0 @@
// Test that `quote`-related macro are gated by `quote` feature gate.
// (To sanity-check the code, uncomment this.)
// #![feature(quote)]
// FIXME the error message that is current emitted seems pretty bad.
// gate-test-quote
#![feature(rustc_private)]
#![allow(dead_code, unused_imports, unused_variables)]
#[macro_use]
extern crate syntax;
use syntax::ast;
use syntax::parse;
struct ParseSess;
impl ParseSess {
fn cfg(&self) -> ast::CrateConfig { loop { } }
fn parse_sess<'a>(&'a self) -> &'a parse::ParseSess { loop { } }
fn call_site(&self) -> () { loop { } }
fn ident_of(&self, st: &str) -> ast::Ident { loop { } }
fn name_of(&self, st: &str) -> ast::Name { loop { } }
}
pub fn main() {
let ecx = &ParseSess;
let x = quote_tokens!(ecx, 3);
//~^ ERROR cannot find macro `quote_tokens!` in this scope
let x = quote_expr!(ecx, 3);
//~^ ERROR cannot find macro `quote_expr!` in this scope
let x = quote_ty!(ecx, 3);
//~^ ERROR cannot find macro `quote_ty!` in this scope
let x = quote_method!(ecx, 3);
//~^ ERROR cannot find macro `quote_method!` in this scope
let x = quote_item!(ecx, 3);
//~^ ERROR cannot find macro `quote_item!` in this scope
let x = quote_pat!(ecx, 3);
//~^ ERROR cannot find macro `quote_pat!` in this scope
let x = quote_arm!(ecx, 3);
//~^ ERROR cannot find macro `quote_arm!` in this scope
let x = quote_stmt!(ecx, 3);
//~^ ERROR cannot find macro `quote_stmt!` in this scope
let x = quote_attr!(ecx, 3);
//~^ ERROR cannot find macro `quote_attr!` in this scope
let x = quote_arg!(ecx, 3);
//~^ ERROR cannot find macro `quote_arg!` in this scope
let x = quote_block!(ecx, 3);
//~^ ERROR cannot find macro `quote_block!` in this scope
let x = quote_meta_item!(ecx, 3);
//~^ ERROR cannot find macro `quote_meta_item!` in this scope
let x = quote_path!(ecx, 3);
//~^ ERROR cannot find macro `quote_path!` in this scope
}

80
src/test/ui-fulldeps/gated-quote.stderr
View File

@ -1,80 +0,0 @@
error: cannot find macro `quote_path!` in this scope
--> $DIR/gated-quote.rs:55:13
|
LL | let x = quote_path!(ecx, 3);
| ^^^^^^^^^^
error: cannot find macro `quote_meta_item!` in this scope
--> $DIR/gated-quote.rs:53:13
|
LL | let x = quote_meta_item!(ecx, 3);
| ^^^^^^^^^^^^^^^
error: cannot find macro `quote_block!` in this scope
--> $DIR/gated-quote.rs:51:13
|
LL | let x = quote_block!(ecx, 3);
| ^^^^^^^^^^^
error: cannot find macro `quote_arg!` in this scope
--> $DIR/gated-quote.rs:49:13
|
LL | let x = quote_arg!(ecx, 3);
| ^^^^^^^^^
error: cannot find macro `quote_attr!` in this scope
--> $DIR/gated-quote.rs:47:13
|
LL | let x = quote_attr!(ecx, 3);
| ^^^^^^^^^^
error: cannot find macro `quote_stmt!` in this scope
--> $DIR/gated-quote.rs:45:13
|
LL | let x = quote_stmt!(ecx, 3);
| ^^^^^^^^^^
error: cannot find macro `quote_arm!` in this scope
--> $DIR/gated-quote.rs:43:13
|
LL | let x = quote_arm!(ecx, 3);
| ^^^^^^^^^
error: cannot find macro `quote_pat!` in this scope
--> $DIR/gated-quote.rs:41:13
|
LL | let x = quote_pat!(ecx, 3);
| ^^^^^^^^^
error: cannot find macro `quote_item!` in this scope
--> $DIR/gated-quote.rs:39:13
|
LL | let x = quote_item!(ecx, 3);
| ^^^^^^^^^^
error: cannot find macro `quote_method!` in this scope
--> $DIR/gated-quote.rs:37:13
|
LL | let x = quote_method!(ecx, 3);
| ^^^^^^^^^^^^
error: cannot find macro `quote_ty!` in this scope
--> $DIR/gated-quote.rs:35:13
|
LL | let x = quote_ty!(ecx, 3);
| ^^^^^^^^
error: cannot find macro `quote_expr!` in this scope
--> $DIR/gated-quote.rs:33:13
|
LL | let x = quote_expr!(ecx, 3);
| ^^^^^^^^^^
error: cannot find macro `quote_tokens!` in this scope
--> $DIR/gated-quote.rs:31:13
|
LL | let x = quote_tokens!(ecx, 3);
| ^^^^^^^^^^^^
error: aborting due to 13 previous errors

16
src/test/ui-fulldeps/issue-48941.rs
View File

@ -1,16 +0,0 @@
// This is a regression test against an ICE that used to occur
// on malformed attributes for a custom MultiModifier.
// aux-build:macro_crate_test.rs
// ignore-stage1
#![feature(plugin)]
#![plugin(macro_crate_test)]
#[noop_attribute("hi", rank = a)] //~ ERROR expected unsuffixed literal or identifier, found a
fn knight() { }
#[noop_attribute("/user", data= = "<user")] //~ ERROR literal or identifier
fn nite() { }
fn main() {}

14
src/test/ui-fulldeps/issue-48941.stderr
View File

@ -1,14 +0,0 @@
error: expected unsuffixed literal or identifier, found a
--> $DIR/issue-48941.rs:10:24
|
LL | #[noop_attribute("hi", rank = a)] //~ ERROR expected unsuffixed literal or identifier, found a
| ^^^^
error: expected unsuffixed literal or identifier, found =
--> $DIR/issue-48941.rs:13:27
|
LL | #[noop_attribute("/user", data= = "<user")] //~ ERROR literal or identifier
| ^^^^
error: aborting due to 2 previous errors

8
src/test/ui-fulldeps/macro-crate-doesnt-resolve.rs
View File

@ -1,8 +0,0 @@
// aux-build:macro_crate_test.rs
#[macro_use] #[no_link]
extern crate macro_crate_test;
fn main() {
macro_crate_test::foo(); //~ ERROR cannot find function `foo` in module `macro_crate_test`
}

9
src/test/ui-fulldeps/macro-crate-doesnt-resolve.stderr
View File

@ -1,9 +0,0 @@
error[E0425]: cannot find function `foo` in module `macro_crate_test`
--> $DIR/macro-crate-doesnt-resolve.rs:7:23
|
LL | macro_crate_test::foo(); //~ ERROR cannot find function `foo` in module `macro_crate_test`
| ^^^ not found in `macro_crate_test`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0425`.

9
src/test/ui-fulldeps/macro-crate-unexported-macro.rs
View File

@ -1,9 +0,0 @@
// aux-build:macro_crate_test.rs
#[macro_use] #[no_link]
extern crate macro_crate_test;
fn main() {
unexported_macro!();
//~^ ERROR cannot find macro `unexported_macro!` in this scope
}

8
src/test/ui-fulldeps/macro-crate-unexported-macro.stderr
View File

@ -1,8 +0,0 @@
error: cannot find macro `unexported_macro!` in this scope
--> $DIR/macro-crate-unexported-macro.rs:7:5
|
LL | unexported_macro!();
| ^^^^^^^^^^^^^^^^ help: you could try the macro: `exported_macro`
error: aborting due to previous error

6
src/test/ui-fulldeps/plugin-as-extern-crate.rs
View File

@ -1,12 +1,12 @@
// aux-build:macro_crate_test.rs
// aux-build:attr_plugin_test.rs
// ignore-cross-compile
//
// macro_crate_test will not compile on a cross-compiled target because
// attr_plugin_test will not compile on a cross-compiled target because
// libsyntax is not compiled for it.
#![deny(plugin_as_library)]
#![allow(unused_extern_crates)]
extern crate macro_crate_test; //~ ERROR compiler plugin used as an ordinary library
extern crate attr_plugin_test; //~ ERROR compiler plugin used as an ordinary library
fn main() { }

2
src/test/ui-fulldeps/plugin-as-extern-crate.stderr
View File

@ -1,7 +1,7 @@
error: compiler plugin used as an ordinary library
--> $DIR/plugin-as-extern-crate.rs:10:1
|
LL | extern crate macro_crate_test; //~ ERROR compiler plugin used as an ordinary library
LL | extern crate attr_plugin_test; //~ ERROR compiler plugin used as an ordinary library
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: lint level defined here

17
src/test/ui-fulldeps/plugin-plus-extern-crate.rs
View File

@ -1,17 +0,0 @@
// aux-build:macro_crate_test.rs
// ignore-stage1
// ignore-cross-compile
//
// macro_crate_test will not compile on a cross-compiled target because
// libsyntax is not compiled for it.
#![deny(plugin_as_library)]
#![feature(plugin)]
#![plugin(macro_crate_test)]
extern crate macro_crate_test; //~ ERROR compiler plugin used as an ordinary library
fn main() {
assert_eq!(1, make_a_1!());
macro_crate_test::foo();
}

14
src/test/ui-fulldeps/plugin-plus-extern-crate.stderr
View File

@ -1,14 +0,0 @@
error: compiler plugin used as an ordinary library
--> $DIR/plugin-plus-extern-crate.rs:12:1
|
LL | extern crate macro_crate_test; //~ ERROR compiler plugin used as an ordinary library
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: lint level defined here
--> $DIR/plugin-plus-extern-crate.rs:8:9
|
LL | #![deny(plugin_as_library)]
| ^^^^^^^^^^^^^^^^^
error: aborting due to previous error

27
src/test/ui-fulldeps/qquote.rs
View File

@ -1,27 +0,0 @@
// ignore-cross-compile
#![feature(quote, rustc_private)]
extern crate syntax;
extern crate syntax_pos;
use syntax::ast;
use syntax::source_map::FilePathMapping;
use syntax::print::pprust;
use syntax::symbol::Symbol;
use syntax_pos::DUMMY_SP;
fn main() {
let ps = syntax::parse::ParseSess::new(FilePathMapping::empty());
let mut resolver = syntax::ext::base::DummyResolver;
let mut cx = syntax::ext::base::ExtCtxt::new(
&ps,
syntax::ext::expand::ExpansionConfig::default("qquote".to_string()),
&mut resolver);
let cx = &mut cx;
assert_eq!(pprust::expr_to_string(&*quote_expr!(&cx, 23)), "23");
let expr = quote_expr!(&cx, 2 - $abcd + 7); //~ ERROR cannot find value `abcd` in this scope
assert_eq!(pprust::expr_to_string(&*expr), "2 - $abcd + 7");
}

9
src/test/ui-fulldeps/qquote.stderr
View File

@ -1,9 +0,0 @@
error[E0425]: cannot find value `abcd` in this scope
--> $DIR/qquote.rs:25:38
|
LL | let expr = quote_expr!(&cx, 2 - $abcd + 7); //~ ERROR cannot find value `abcd` in this scope
| ^^^^ not found in this scope
error: aborting due to previous error
For more information about this error, try `rustc --explain E0425`.

14
src/test/ui/quote-with-interpolated.rs
View File

@ -1,14 +0,0 @@
#![feature(quote)]
fn main() {
macro_rules! foo {
($bar:expr) => {
quote_expr!(cx, $bar)
//~^ ERROR quote! with interpolated token
//~| ERROR failed to resolve: maybe a missing `extern crate syntax;`?
//~| ERROR failed to resolve: maybe a missing `extern crate syntax;`?
//~| ERROR cannot find value `cx` in this scope
//~| ERROR cannot find function `new_parser_from_tts` in this scope
}
}
foo!(bar);
}

40
src/test/ui/quote-with-interpolated.stderr
View File

@ -1,40 +0,0 @@
error: quote! with interpolated token
--> $DIR/quote-with-interpolated.rs:5:29
|
LL | quote_expr!(cx, $bar)
| ^^^^
...
LL | foo!(bar);
| ---------- in this macro invocation
error[E0433]: failed to resolve: maybe a missing `extern crate syntax;`?
--> $DIR/quote-with-interpolated.rs:5:13
|
LL | quote_expr!(cx, $bar)
| ^^^^^^^^^^^^^^^^^^^^^ maybe a missing `extern crate syntax;`?
error[E0433]: failed to resolve: maybe a missing `extern crate syntax;`?
--> $DIR/quote-with-interpolated.rs:5:29
|
LL | quote_expr!(cx, $bar)
| ^^^^ maybe a missing `extern crate syntax;`?
error[E0425]: cannot find value `cx` in this scope
--> $DIR/quote-with-interpolated.rs:5:25
|
LL | quote_expr!(cx, $bar)
| ^^ not found in this scope
...
LL | foo!(bar);
| ---------- in this macro invocation
error[E0425]: cannot find function `new_parser_from_tts` in this scope
--> $DIR/quote-with-interpolated.rs:5:13
|
LL | quote_expr!(cx, $bar)
| ^^^^^^^^^^^^^^^^^^^^^ not found in this scope
error: aborting due to 5 previous errors
Some errors occurred: E0425, E0433.
For more information about an error, try `rustc --explain E0425`.