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

Auto merge of #51285 - Mark-Simulacrum:remove-quote_apis, r=Manishearth

Browse Source 
Remove quote_*! macros

This deletes a considerable amount of test cases, some of which we may want to keep. I'm not entirely certain what the primary intent of many of them was; if we should keep them I can attempt to edit each case to continue compiling without the quote_*! macros involved.

Fixes #46849.
Fixes #12265.
Fixes #12266.
Fixes #26994.

r? @Manishearth
This commit is contained in:
bors 2019-01-24 15:48:46 +00:00
commit 01f8e25b15
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

@ -1286,9 +1286,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`.