bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity
rust/src/libsyntax/ext/expand.rs

2106 lines
81 KiB
Rust
Raw Normal View History

Stop unloading syntax libraries Externally loaded libraries are able to do things that cause references to them to survive past the expansion phase (e.g. creating @-box cycles, launching a task or storing something in task local data). As such, the library has to stay loaded for the lifetime of the process.
2014-02-11 22:43:23 -08:00
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
Update license, add license boilerplate to most files. Remainder will follow.
2012-12-03 16:48:01 -08:00
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
use ast::{Block, Crate, DeclLocal, ExprMac, PatMac};
libsyntax: Renamed types, traits and enum variants to CamelCase.
2014-01-09 15:05:33 +02:00
use ast::{Local, Ident, MacInvocTT};
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
use ast::{ItemMac, MacStmtWithSemicolon, Mrk, Stmt, StmtDecl, StmtMac};
use ast::{StmtExpr, StmtSemi};
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
use ast::TokenTree;
librustc: Terminate name searches at the nearest module scope for paths that contain at least two components. r=graydon
2012-12-23 17:41:37 -05:00
use ast;
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
use ext::mtwt;
syntax: aesthetic improvements to the `for` desugaring.
2013-09-08 22:46:20 +10:00
use ext::build::AstBuilder;
libsyntax and librustc: minor cleanup
2013-02-11 08:36:42 -08:00
use attr;
syntax: modernise attribute handling in syntax::attr. This does a number of things, but especially dramatically reduce the number of allocations performed for operations involving attributes/ meta items: - Converts ast::meta_item & ast::attribute and other associated enums to CamelCase. - Converts several standalone functions in syntax::attr into methods, defined on two traits AttrMetaMethods & AttributeMethods. The former is common to both MetaItem and Attribute since the latter is a thin wrapper around the former. - Deletes functions that are unnecessary due to iterators. - Converts other standalone functions to use iterators and the generic AttrMetaMethods rather than allocating a lot of new vectors (e.g. the old code would have to allocate a new vector to use functions that operated on &[meta_item] on &[attribute].) - Moves the core algorithm of the #[cfg] matching to syntax::attr, similar to find_inline_attr and find_linkage_metas. This doesn't have much of an effect on the speed of #[cfg] stripping, despite hugely reducing the number of allocations performed; presumably most of the time is spent in the ast folder rather than doing attribute checks. Also fixes the Eq instance of MetaItem_ to correctly ignore spaces, so that `rustc --cfg 'foo(bar)'` now works.
2013-07-19 21:51:37 +10:00
use attr::AttrMetaMethods;
Fix implicit leaks of imports throughout libraries Also touch up use of 'pub' and move some tests around so the tested functions don't have to be 'pub'
2013-02-25 14:11:21 -05:00
use codemap;
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
use codemap::{Span, Spanned, ExpnInfo, NameAndSpan, MacroBang, MacroAttribute, CompilerExpansion};
libsyntax: "import" -> "use"
2012-09-04 11:37:29 -07:00
use ext::base::*;
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
use feature_gate::{self, Features};
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
use fold;
librustc: Terminate name searches at the nearest module scope for paths that contain at least two components. r=graydon
2012-12-23 17:41:37 -05:00
use fold::*;
Fix implicit leaks of imports throughout libraries Also touch up use of 'pub' and move some tests around so the tested functions don't have to be 'pub'
2013-02-25 14:11:21 -05:00
use parse;
libsyntax: Remove many uses of `token::ident_to_str`
2014-01-31 15:26:59 -08:00
use parse::token::{fresh_mark, fresh_name, intern};
syntax: implement foreach .. in .. { .. } via desugaring.
2013-07-29 17:25:00 -07:00
use parse::token;
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
use ptr::P;
use util::small_vector::SmallVector;
add hygiene support functions
2013-06-04 14:56:33 -07:00
use visit;
remove unused import warnings
2013-06-09 02:21:11 +10:00
use visit::Visitor;
Don't use std:: paths in syntax extensions when compiling a #![no_std] crate Fixes #16803. Fixes #14342. Fixes half of #21827 -- slice syntax is still broken.
2014-09-07 14:57:26 -07:00
use std_inject;
Add backtraces for syntax problems.
2011-08-05 13:06:11 -07:00
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
pub fn expand_expr(e: P<ast::Expr>, fld: &mut MacroExpander) -> P<ast::Expr> {
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
fn push_compiler_expansion(fld: &mut MacroExpander, span: Span, expansion_desc: &str) {
fld.cx.bt_push(ExpnInfo {
call_site: span,
callee: NameAndSpan {
name: expansion_desc.to_string(),
format: CompilerExpansion,
allow_internal_unstable: true,
span: None,
},
});
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
e.and_then(|ast::Expr {id, node, span}| match node {
libsyntax: progress on making syntax::visit vecs_implicitly_copyable-free
2013-02-17 22:20:36 -08:00
// expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions.
Desugar 'if let' into the appropriate 'match'
2014-08-24 19:08:48 -07:00
ast::ExprMac(mac) => {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let expanded_expr = match expand_mac_invoc(mac, span,
|r| r.make_expr(),
mark_expr, fld) {
expansion abstraction
2014-07-12 15:00:23 -07:00
Some(expr) => expr,
None => {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
return DummyResult::raw_expr(span);
expansion abstraction
2014-07-12 15:00:23 -07:00
}
};
Use ~-objects instead of @-objects for syntax exts This is necessary for #11151 to make sure dtors run before the libraries are unloaded.
2014-01-05 18:02:57 -08:00
expansion abstraction
2014-07-12 15:00:23 -07:00
// Keep going, outside-in.
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let fully_expanded = fld.fold_expr(expanded_expr);
save-analysis: API-ify paths
2015-07-08 14:30:18 +12:00
let span = fld.new_span(span);
expansion abstraction
2014-07-12 15:00:23 -07:00
fld.cx.bt_pop();
Use ~-objects instead of @-objects for syntax exts This is necessary for #11151 to make sure dtors run before the libraries are unloaded.
2014-01-05 18:02:57 -08:00
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fully_expanded.map(|e| ast::Expr {
expansion abstraction
2014-07-12 15:00:23 -07:00
id: ast::DUMMY_NODE_ID,
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
node: e.node,
Fix a bug where macros in expression position don't have expansion inidices in their spans
2015-07-08 14:29:43 +12:00
span: span,
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
})
libsyntax: progress on making syntax::visit vecs_implicitly_copyable-free
2013-02-17 22:20:36 -08:00
}
syntax: implement foreach .. in .. { .. } via desugaring.
2013-07-29 17:25:00 -07:00
Add support for labeled while loops.
2014-07-25 20:12:51 -04:00
ast::ExprWhile(cond, body, opt_ident) => {
let cond = fld.fold_expr(cond);
let (body, opt_ident) = expand_loop_block(body, opt_ident, fld);
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fld.cx.expr(span, ast::ExprWhile(cond, body, opt_ident))
Add support for labeled while loops.
2014-07-25 20:12:51 -04:00
}
Teach libsyntax about `while let`
2014-10-02 22:45:46 -04:00
// Desugar ExprWhileLet
// From: `[opt_ident]: while let <pat> = <expr> <body>`
ast::ExprWhileLet(pat, expr, body, opt_ident) => {
// to:
//
// [opt_ident]: loop {
// match <expr> {
// <pat> => <body>,
// _ => break
// }
// }
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
push_compiler_expansion(fld, span, "while let expansion");
Teach libsyntax about `while let`
2014-10-02 22:45:46 -04:00
// `<pat> => <body>`
let pat_arm = {
let body_expr = fld.cx.expr_block(body);
fld.cx.arm(pat.span, vec![pat], body_expr)
};
// `_ => break`
let break_arm = {
let pat_under = fld.cx.pat_wild(span);
let break_expr = fld.cx.expr_break(span);
fld.cx.arm(span, vec![pat_under], break_expr)
};
// `match <expr> { ... }`
let arms = vec![pat_arm, break_arm];
let match_expr = fld.cx.expr(span,
Drop the Match prefix from the MatchSource variants
2014-12-20 07:58:02 +09:00
ast::ExprMatch(expr, arms, ast::MatchSource::WhileLetDesugar));
Teach libsyntax about `while let`
2014-10-02 22:45:46 -04:00
// `[opt_ident]: loop { ... }`
let loop_block = fld.cx.block_expr(match_expr);
let (loop_block, opt_ident) = expand_loop_block(loop_block, opt_ident, fld);
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
let result = fld.cx.expr(span, ast::ExprLoop(loop_block, opt_ident));
fld.cx.bt_pop();
result
Teach libsyntax about `while let`
2014-10-02 22:45:46 -04:00
}
Desugar 'if let' into the appropriate 'match'
2014-08-24 19:08:48 -07:00
// Desugar ExprIfLet
// From: `if let <pat> = <expr> <body> [<elseopt>]`
ast::ExprIfLet(pat, expr, body, mut elseopt) => {
// to:
//
// match <expr> {
// <pat> => <body>,
// [_ if <elseopt_if_cond> => <elseopt_if_body>,]
// _ => [<elseopt> | ()]
// }
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
push_compiler_expansion(fld, span, "if let expansion");
Desugar 'if let' into the appropriate 'match'
2014-08-24 19:08:48 -07:00
// `<pat> => <body>`
let pat_arm = {
let body_expr = fld.cx.expr_block(body);
fld.cx.arm(pat.span, vec![pat], body_expr)
};
// `[_ if <elseopt_if_cond> => <elseopt_if_body>,]`
let else_if_arms = {
let mut arms = vec![];
loop {
Update after the fall out from the syntax::ptr changes
2014-09-29 22:45:26 +02:00
let elseopt_continue = elseopt
.and_then(|els| els.and_then(|els| match els.node {
// else if
ast::ExprIf(cond, then, elseopt) => {
let pat_under = fld.cx.pat_wild(span);
arms.push(ast::Arm {
attrs: vec![],
pats: vec![pat_under],
guard: Some(cond),
body: fld.cx.expr_block(then)
});
elseopt.map(|elseopt| (elseopt, true))
}
_ => Some((P(els), false))
}));
match elseopt_continue {
Some((e, true)) => {
elseopt = Some(e);
}
Some((e, false)) => {
elseopt = Some(e);
break;
}
None => {
elseopt = None;
break;
}
Desugar 'if let' into the appropriate 'match'
2014-08-24 19:08:48 -07:00
}
}
arms
};
Drop the Match prefix from the MatchSource variants
2014-12-20 07:58:02 +09:00
let contains_else_clause = elseopt.is_some();
Desugar 'if let' into the appropriate 'match'
2014-08-24 19:08:48 -07:00
// `_ => [<elseopt> | ()]`
let else_arm = {
let pat_under = fld.cx.pat_wild(span);
Complete the removal of ty_nil, ast::LitNil, ast::TyBot and ast::TyUniq [breaking-change] This will break any uses of macros that assumed () being a valid literal.
2014-11-09 16:14:15 +01:00
let else_expr = elseopt.unwrap_or_else(|| fld.cx.expr_tuple(span, vec![]));
Desugar 'if let' into the appropriate 'match'
2014-08-24 19:08:48 -07:00
fld.cx.arm(span, vec![pat_under], else_expr)
};
let mut arms = Vec::with_capacity(else_if_arms.len() + 2);
arms.push(pat_arm);
Removed many pointless calls to *iter() and iter_mut()
2015-06-10 17:22:20 +01:00
arms.extend(else_if_arms);
Desugar 'if let' into the appropriate 'match'
2014-08-24 19:08:48 -07:00
arms.push(else_arm);
Drop the Match prefix from the MatchSource variants
2014-12-20 07:58:02 +09:00
let match_expr = fld.cx.expr(span,
ast::ExprMatch(expr, arms,
ast::MatchSource::IfLetDesugar {
contains_else_clause: contains_else_clause,
}));
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
let result = fld.fold_expr(match_expr);
fld.cx.bt_pop();
result
Desugar 'if let' into the appropriate 'match'
2014-08-24 19:08:48 -07:00
}
// Desugar support for ExprIfLet in the ExprIf else position
Update based on PR feedback
2014-08-27 21:34:03 -07:00
ast::ExprIf(cond, blk, elseopt) => {
Update after the fall out from the syntax::ptr changes
2014-09-29 22:45:26 +02:00
let elseopt = elseopt.map(|els| els.and_then(|els| match els.node {
Update based on PR feedback
2014-08-27 21:34:03 -07:00
ast::ExprIfLet(..) => {
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
push_compiler_expansion(fld, span, "if let expansion");
Update based on PR feedback
2014-08-27 21:34:03 -07:00
// wrap the if-let expr in a block
Update after the fall out from the syntax::ptr changes
2014-09-29 22:45:26 +02:00
let span = els.span;
Update based on PR feedback
2014-08-27 21:34:03 -07:00
let blk = P(ast::Block {
stmts: vec![],
Update after the fall out from the syntax::ptr changes
2014-09-29 22:45:26 +02:00
expr: Some(P(els)),
Update based on PR feedback
2014-08-27 21:34:03 -07:00
id: ast::DUMMY_NODE_ID,
rules: ast::DefaultBlock,
Update after the fall out from the syntax::ptr changes
2014-09-29 22:45:26 +02:00
span: span
Update based on PR feedback
2014-08-27 21:34:03 -07:00
});
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
let result = fld.cx.expr_block(blk);
fld.cx.bt_pop();
result
Update based on PR feedback
2014-08-27 21:34:03 -07:00
}
Update after the fall out from the syntax::ptr changes
2014-09-29 22:45:26 +02:00
_ => P(els)
}));
let if_expr = fld.cx.expr(span, ast::ExprIf(cond, blk, elseopt));
if_expr.map(|e| noop_fold_expr(e, fld))
Desugar 'if let' into the appropriate 'match'
2014-08-24 19:08:48 -07:00
}
Make break and continue hygienic Makes labelled loops hygiene by performing renaming of the labels defined in e.g. `'x: loop { ... }` and then used in break and continue statements within loop body so that they act hygienically when used with macros. Closes #12262.
2014-02-15 16:54:32 +08:00
ast::ExprLoop(loop_block, opt_ident) => {
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
let (loop_block, opt_ident) = expand_loop_block(loop_block, opt_ident, fld);
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fld.cx.expr(span, ast::ExprLoop(loop_block, opt_ident))
Make break and continue hygienic Makes labelled loops hygiene by performing renaming of the labels defined in e.g. `'x: loop { ... }` and then used in break and continue statements within loop body so that they act hygienically when used with macros. Closes #12262.
2014-02-15 16:54:32 +08:00
}
implement for loop desugaring
2015-01-08 18:04:26 -05:00
// Desugar ExprForLoop
// From: `[opt_ident]: for <pat> in <head> <body>`
librustc: Stop desugaring `for` expressions and translate them directly. This makes edge cases in which the `Iterator` trait was not in scope and/or `Option` or its variants were not in scope work properly. This breaks code that looks like: struct MyStruct { ... } impl MyStruct { fn next(&mut self) -> Option<int> { ... } } for x in MyStruct { ... } { ... } Change ad-hoc `next` methods like the above to implementations of the `Iterator` trait. For example: impl Iterator<int> for MyStruct { fn next(&mut self) -> Option<int> { ... } } Closes #15392. [breaking-change]
2014-07-21 20:54:28 -07:00
ast::ExprForLoop(pat, head, body, opt_ident) => {
implement for loop desugaring
2015-01-08 18:04:26 -05:00
// to:
//
make `for PAT in ITER_EXPR { ... }` a terminating-scope for ITER_EXPR. In effect, temporary anonymous values created during the evaluation of ITER_EXPR no longer not live for the entirety of the block surrounding the for-loop; instead they only live for the extent of the for-loop itself, and no longer. ---- There is one case I know of that this breaks, demonstrated to me by niko (but it is also a corner-case that is useless in practice). Here is that case: ``` fn main() { let mut foo: Vec<&i8> = Vec::new(); for i in &[1, 2, 3] { foo.push(i) } } ``` Note that if you add any code following the for-loop above, or even a semicolon to the end of it, then the code will stop compiling (i.e., it gathers a vector of references but the gathered vector cannot actually be used.) (The above code, despite being useless, did occur in one run-pass test by accident; that test is updated here to accommodate the new striction.) ---- So, technically this is a: [breaking-change]
2015-02-04 13:24:44 +01:00
// {
// let result = match ::std::iter::IntoIterator::into_iter(<head>) {
// mut iter => {
// [opt_ident]: loop {
// match ::std::iter::Iterator::next(&mut iter) {
// ::std::option::Option::Some(<pat>) => <body>,
// ::std::option::Option::None => break
// }
implement for loop desugaring
2015-01-08 18:04:26 -05:00
// }
// }
make `for PAT in ITER_EXPR { ... }` a terminating-scope for ITER_EXPR. In effect, temporary anonymous values created during the evaluation of ITER_EXPR no longer not live for the entirety of the block surrounding the for-loop; instead they only live for the extent of the for-loop itself, and no longer. ---- There is one case I know of that this breaks, demonstrated to me by niko (but it is also a corner-case that is useless in practice). Here is that case: ``` fn main() { let mut foo: Vec<&i8> = Vec::new(); for i in &[1, 2, 3] { foo.push(i) } } ``` Note that if you add any code following the for-loop above, or even a semicolon to the end of it, then the code will stop compiling (i.e., it gathers a vector of references but the gathered vector cannot actually be used.) (The above code, despite being useless, did occur in one run-pass test by accident; that test is updated here to accommodate the new striction.) ---- So, technically this is a: [breaking-change]
2015-02-04 13:24:44 +01:00
// };
// result
implement for loop desugaring
2015-01-08 18:04:26 -05:00
// }
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
push_compiler_expansion(fld, span, "for loop expansion");
let span = fld.new_span(span);
implement for loop desugaring
2015-01-08 18:04:26 -05:00
// expand <head>
librustc: Stop desugaring `for` expressions and translate them directly. This makes edge cases in which the `Iterator` trait was not in scope and/or `Option` or its variants were not in scope work properly. This breaks code that looks like: struct MyStruct { ... } impl MyStruct { fn next(&mut self) -> Option<int> { ... } } for x in MyStruct { ... } { ... } Change ad-hoc `next` methods like the above to implementations of the `Iterator` trait. For example: impl Iterator<int> for MyStruct { fn next(&mut self) -> Option<int> { ... } } Closes #15392. [breaking-change]
2014-07-21 20:54:28 -07:00
let head = fld.fold_expr(head);
implement for loop desugaring
2015-01-08 18:04:26 -05:00
// create an hygienic ident
let iter = {
let ident = fld.cx.ident_of("iter");
let new_ident = fresh_name(&ident);
let rename = (ident, new_ident);
let mut rename_list = vec![rename];
let mut rename_fld = IdentRenamer{ renames: &mut rename_list };
rename_fld.fold_ident(ident)
};
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
let pat_span = fld.new_span(pat.span);
// `::std::option::Option::Some(<pat>) => <body>`
implement for loop desugaring
2015-01-08 18:04:26 -05:00
let pat_arm = {
let body_expr = fld.cx.expr_block(body);
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
let pat = noop_fold_pat(pat, fld);
implement for loop desugaring
2015-01-08 18:04:26 -05:00
let some_pat = fld.cx.pat_some(pat_span, pat);
fld.cx.arm(pat_span, vec![some_pat], body_expr)
};
// `::std::option::Option::None => break`
let break_arm = {
let break_expr = fld.cx.expr_break(span);
fld.cx.arm(span, vec![fld.cx.pat_none(span)], break_expr)
};
// `match ::std::iter::Iterator::next(&mut iter) { ... }`
let match_expr = {
let next_path = {
let strs = vec![
Don't use std:: paths in syntax extensions when compiling a #![no_std] crate Fixes #16803. Fixes #14342. Fixes half of #21827 -- slice syntax is still broken.
2014-09-07 14:57:26 -07:00
fld.cx.ident_of_std("core"),
implement for loop desugaring
2015-01-08 18:04:26 -05:00
fld.cx.ident_of("iter"),
fld.cx.ident_of("Iterator"),
fld.cx.ident_of("next"),
];
fld.cx.path_global(span, strs)
};
let ref_mut_iter = fld.cx.expr_mut_addr_of(span, fld.cx.expr_ident(span, iter));
let next_expr =
fld.cx.expr_call(span, fld.cx.expr_path(next_path), vec![ref_mut_iter]);
let arms = vec![pat_arm, break_arm];
custom message for refutable patterns in for loops
2015-01-22 17:46:40 -05:00
fld.cx.expr(pat_span,
ast::ExprMatch(next_expr, arms, ast::MatchSource::ForLoopDesugar))
implement for loop desugaring
2015-01-08 18:04:26 -05:00
};
// `[opt_ident]: loop { ... }`
let loop_block = fld.cx.block_expr(match_expr);
let (loop_block, opt_ident) = expand_loop_block(loop_block, opt_ident, fld);
let loop_expr = fld.cx.expr(span, ast::ExprLoop(loop_block, opt_ident));
// `mut iter => { ... }`
let iter_arm = {
let iter_pat =
fld.cx.pat_ident_binding_mode(span, iter, ast::BindByValue(ast::MutMutable));
fld.cx.arm(span, vec![iter_pat], loop_expr)
};
// `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
let into_iter_expr = {
let into_iter_path = {
let strs = vec![
Don't use std:: paths in syntax extensions when compiling a #![no_std] crate Fixes #16803. Fixes #14342. Fixes half of #21827 -- slice syntax is still broken.
2014-09-07 14:57:26 -07:00
fld.cx.ident_of_std("core"),
implement for loop desugaring
2015-01-08 18:04:26 -05:00
fld.cx.ident_of("iter"),
fld.cx.ident_of("IntoIterator"),
fld.cx.ident_of("into_iter"),
];
fld.cx.path_global(span, strs)
};
fld.cx.expr_call(span, fld.cx.expr_path(into_iter_path), vec![head])
};
make `for PAT in ITER_EXPR { ... }` a terminating-scope for ITER_EXPR. In effect, temporary anonymous values created during the evaluation of ITER_EXPR no longer not live for the entirety of the block surrounding the for-loop; instead they only live for the extent of the for-loop itself, and no longer. ---- There is one case I know of that this breaks, demonstrated to me by niko (but it is also a corner-case that is useless in practice). Here is that case: ``` fn main() { let mut foo: Vec<&i8> = Vec::new(); for i in &[1, 2, 3] { foo.push(i) } } ``` Note that if you add any code following the for-loop above, or even a semicolon to the end of it, then the code will stop compiling (i.e., it gathers a vector of references but the gathered vector cannot actually be used.) (The above code, despite being useless, did occur in one run-pass test by accident; that test is updated here to accommodate the new striction.) ---- So, technically this is a: [breaking-change]
2015-02-04 13:24:44 +01:00
let match_expr = fld.cx.expr_match(span, into_iter_expr, vec![iter_arm]);
// `{ let result = ...; result }`
let result_ident = token::gensym_ident("result");
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
let result = fld.cx.expr_block(
make `for PAT in ITER_EXPR { ... }` a terminating-scope for ITER_EXPR. In effect, temporary anonymous values created during the evaluation of ITER_EXPR no longer not live for the entirety of the block surrounding the for-loop; instead they only live for the extent of the for-loop itself, and no longer. ---- There is one case I know of that this breaks, demonstrated to me by niko (but it is also a corner-case that is useless in practice). Here is that case: ``` fn main() { let mut foo: Vec<&i8> = Vec::new(); for i in &[1, 2, 3] { foo.push(i) } } ``` Note that if you add any code following the for-loop above, or even a semicolon to the end of it, then the code will stop compiling (i.e., it gathers a vector of references but the gathered vector cannot actually be used.) (The above code, despite being useless, did occur in one run-pass test by accident; that test is updated here to accommodate the new striction.) ---- So, technically this is a: [breaking-change]
2015-02-04 13:24:44 +01:00
fld.cx.block_all(
span,
vec![fld.cx.stmt_let(span, false, result_ident, match_expr)],
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
Some(fld.cx.expr_ident(span, result_ident))));
fld.cx.bt_pop();
result
librustc: Stop desugaring `for` expressions and translate them directly. This makes edge cases in which the `Iterator` trait was not in scope and/or `Option` or its variants were not in scope work properly. This breaks code that looks like: struct MyStruct { ... } impl MyStruct { fn next(&mut self) -> Option<int> { ... } } for x in MyStruct { ... } { ... } Change ad-hoc `next` methods like the above to implementations of the `Iterator` trait. For example: impl Iterator<int> for MyStruct { fn next(&mut self) -> Option<int> { ... } } Closes #15392. [breaking-change]
2014-07-21 20:54:28 -07:00
}
Remove the explicit closure kind syntax from the parser and AST; upgrade the inference based on expected type so that it is able to infer the fn kind in isolation even if the full signature is not available (and we could perhaps do better still in some cases, such as extracting just the types of the arguments but not the return value).
2015-02-03 11:34:05 -05:00
ast::ExprClosure(capture_clause, fn_decl, block) => {
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
push_compiler_expansion(fld, span, "closure expansion");
implement hygiene for ExprFnBlock and ExprProc
2014-07-03 17:20:25 -07:00
let (rewritten_fn_decl, rewritten_block)
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
= expand_and_rename_fn_decl_and_block(fn_decl, block, fld);
Merge the ExprFnBlock and ExprUnboxedClosure into one ExprClosure with an optional unboxed closure kind.
2014-11-19 11:18:17 -05:00
let new_node = ast::ExprClosure(capture_clause,
librustc: Parse, but do not fully turn on, the `ref` keyword for by-reference upvars. This partially implements RFC 38. A snapshot will be needed to turn this on, because stage0 cannot yet parse the keyword. Part of #12381.
2014-07-23 12:43:29 -07:00
rewritten_fn_decl,
rewritten_block);
Proper spans for for loop expansion
2015-05-06 19:17:01 +12:00
let result = P(ast::Expr{id:id, node: new_node, span: fld.new_span(span)});
fld.cx.bt_pop();
result
implement hygiene for ExprFnBlock and ExprProc
2014-07-03 17:20:25 -07:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
_ => {
P(noop_fold_expr(ast::Expr {
id: id,
node: node,
span: span
}, fld))
}
})
Move macro expansion to a separate phase, change macro syntax, and add parse_sess to session.
2011-07-06 15:22:23 -07:00
}
expansion abstraction
2014-07-12 15:00:23 -07:00
/// Expand a (not-ident-style) macro invocation. Returns the result
/// of expansion and the mark which must be applied to the result.
/// Our current interface doesn't allow us to apply the mark to the
/// result until after calling make_expr, make_items, etc.
Fix a bug where macros in expression position don't have expansion inidices in their spans
2015-07-08 14:29:43 +12:00
fn expand_mac_invoc<T, F, G>(mac: ast::Mac,
span: codemap::Span,
libsyntax: use unboxed closures
2014-12-08 13:28:32 -05:00
parse_thunk: F,
mark_thunk: G,
fld: &mut MacroExpander)
-> Option<T> where
Fix fallout in libsyntax from RFC 599. Clarity and efficiency seems to be mostly improved, to my eye. Nonetheless, as this commit demonstrates, the previous commits was a [breaking-change]. In practice, breakage is focused on functions of this form: ```rust fn foo(..., object: Box<FnMut()>) ```` where `FnMut()` could be any trait object type. The older scheme defaulted objects in argument position so that they were bounded by a fresh lifetime: ```rust fn foo<'a>(..., object: Box<FnMut()+'a>) ``` This meant that the object could contain borrowed data. The newer scheme defaults to a lifetime bound of `'static`: ```rust fn foo(..., object: Box<FnMut()+'static>) ``` This means that the object cannot contain borrowed data. In some cases, the best fix is to stop using `Box`: ```rust fn foo(..., object: &mut FnMut()) ``` but another option is to write an explicit annotation for the `'a` lifetime that used to be implicit. Both fixes are demonstrated in this commit.
2015-02-12 10:41:47 -05:00
F: for<'a> FnOnce(Box<MacResult+'a>) -> Option<T>,
libsyntax: use unboxed closures
2014-12-08 13:28:32 -05:00
G: FnOnce(T, Mrk) -> T,
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
{
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
match mac.node {
expansion abstraction
2014-07-12 15:00:23 -07:00
// it would almost certainly be cleaner to pass the whole
// macro invocation in, rather than pulling it apart and
// marking the tts and the ctxt separately. This also goes
// for the other three macro invocation chunks of code
// in this file.
// Token-tree macros:
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
MacInvocTT(pth, tts, _) => {
Omit integer suffix when unnecessary See PR # 21378 for context
2015-01-28 01:01:48 +00:00
if pth.segments.len() > 1 {
expansion abstraction
2014-07-12 15:00:23 -07:00
fld.cx.span_err(pth.span,
"expected macro name without module \
separators");
// let compilation continue
return None;
}
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
let extname = pth.segments[0].identifier;
expansion abstraction
2014-07-12 15:00:23 -07:00
let extnamestr = token::get_ident(extname);
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
match fld.cx.syntax_env.find(&extname.name) {
expansion abstraction
2014-07-12 15:00:23 -07:00
None => {
fld.cx.span_err(
pth.span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("macro undefined: '{}!'",
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
&extnamestr));
expansion abstraction
2014-07-12 15:00:23 -07:00
// let compilation continue
None
}
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
Some(rc) => match *rc {
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
NormalTT(ref expandfun, exp_span, allow_internal_unstable) => {
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
fld.cx.bt_push(ExpnInfo {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
call_site: span,
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
callee: NameAndSpan {
Libsyntax has been updated
2015-02-03 23:31:06 +01:00
name: extnamestr.to_string(),
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
format: MacroBang,
span: exp_span,
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
allow_internal_unstable: allow_internal_unstable,
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
},
});
let fm = fresh_mark();
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
let marked_before = mark_tts(&tts[..], fm);
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
// The span that we pass to the expanders we want to
// be the root of the call stack. That's the most
// relevant span and it's the actual invocation of
// the macro.
syntax: use an index in CodeMap instead of Gc for ExpnInfo.
2014-09-17 19:01:33 +03:00
let mac_span = fld.cx.original_span();
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
let opt_parsed = {
let expanded = expandfun.expand(fld.cx,
syntax: use an index in CodeMap instead of Gc for ExpnInfo.
2014-09-17 19:01:33 +03:00
mac_span,
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
&marked_before[..]);
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
parse_thunk(expanded)
};
let parsed = match opt_parsed {
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
Some(e) => e,
None => {
fld.cx.span_err(
pth.span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("non-expression macro in expression position: {}",
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
&extnamestr[..]
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
));
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
return None;
}
};
Some(mark_thunk(parsed,fm))
}
_ => {
fld.cx.span_err(
pth.span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("'{}' is not a tt-style macro",
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
&extnamestr));
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
None
}
expansion abstraction
2014-07-12 15:00:23 -07:00
}
}
}
}
}
syntax: doc comments all the things
2014-06-09 13:12:30 -07:00
/// Rename loop label and expand its loop body
///
/// The renaming procedure for loop is different in the sense that the loop
/// body is in a block enclosed by loop head so the renaming of loop label
/// must be propagated to the enclosed context.
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
fn expand_loop_block(loop_block: P<Block>,
opt_ident: Option<Ident>,
fld: &mut MacroExpander) -> (P<Block>, Option<Ident>) {
Make break and continue hygienic Makes labelled loops hygiene by performing renaming of the labels defined in e.g. `'x: loop { ... }` and then used in break and continue statements within loop body so that they act hygienically when used with macros. Closes #12262.
2014-02-15 16:54:32 +08:00
match opt_ident {
Some(label) => {
let new_label = fresh_name(&label);
let rename = (label, new_label);
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
// The rename *must not* be added to the pending list of current
// syntax context otherwise an unrelated `break` or `continue` in
// the same context will pick that up in the deferred renaming pass
// and be renamed incorrectly.
let mut rename_list = vec!(rename);
get rid of needless wrapper function
2014-06-26 13:18:52 -07:00
let mut rename_fld = IdentRenamer{renames: &mut rename_list};
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
let renamed_ident = rename_fld.fold_ident(label);
// The rename *must* be added to the enclosed syntax context for
// `break` or `continue` to pick up because by definition they are
// in a block enclosed by loop head.
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
fld.cx.syntax_env.push_frame();
fld.cx.syntax_env.info().pending_renames.push(rename);
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let expanded_block = expand_block_elts(loop_block, fld);
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
fld.cx.syntax_env.pop_frame();
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
(expanded_block, Some(renamed_ident))
Make break and continue hygienic Makes labelled loops hygiene by performing renaming of the labels defined in e.g. `'x: loop { ... }` and then used in break and continue statements within loop body so that they act hygienically when used with macros. Closes #12262.
2014-02-15 16:54:32 +08:00
}
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
None => (fld.fold_block(loop_block), opt_ident)
Make break and continue hygienic Makes labelled loops hygiene by performing renaming of the labels defined in e.g. `'x: loop { ... }` and then used in break and continue statements within loop body so that they act hygienically when used with macros. Closes #12262.
2014-02-15 16:54:32 +08:00
}
}
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
// eval $e with a new exts frame.
// must be a macro so that $e isn't evaluated too early.
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
macro_rules! with_exts_frame {
change to newer macro escape mechanism, using uints in more places
2013-05-08 15:27:29 -07:00
($extsboxexpr:expr,$macros_escape:expr,$e:expr) =>
Rewrite SyntaxEnv I'd really like to be able to do something like struct MapChain<'next, K, V> { info: BlockInfo, map: HashMap<K, V>, next: Option<&'next mut MapChain<'next, K, V> } but I can't get the lifetimes to work out.
2013-12-30 17:45:39 -08:00
({$extsboxexpr.push_frame();
$extsboxexpr.info().macros_escape = $macros_escape;
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
let result = $e;
Rewrite SyntaxEnv I'd really like to be able to do something like struct MapChain<'next, K, V> { info: BlockInfo, map: HashMap<K, V>, next: Option<&'next mut MapChain<'next, K, V> } but I can't get the lifetimes to work out.
2013-12-30 17:45:39 -08:00
$extsboxexpr.pop_frame();
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
result
})
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
}
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
Rename `#mod` -> `#module` to not collide with the keyword.
2012-07-27 11:19:21 -07:00
// When we enter a module, record it, for the sake of `module!`
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
pub fn expand_item(it: P<ast::Item>, fld: &mut MacroExpander)
-> SmallVector<P<ast::Item>> {
Add an ItemModifier syntax extension type Where ItemDecorator creates new items given a single item, ItemModifier alters the tagged item in place. The expansion rules for this are a bit weird, but I think are the most reasonable option available. When an item is expanded, all ItemModifier attributes are stripped from it and the item is folded through all ItemModifiers. At that point, the process repeats until there are no ItemModifiers in the new item.
2014-02-27 23:49:25 -08:00
let it = expand_item_modifiers(it, fld);
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
expand_annotatable(Annotatable::Item(it), fld)
.into_iter().map(|i| i.expect_item()).collect()
add #mod[], which expands to the current module path
2012-05-18 10:00:49 -07:00
}
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
/// Expand item_underscore
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn expand_item_underscore(item: ast::Item_, fld: &mut MacroExpander) -> ast::Item_ {
match item {
syntax: parse `const fn` for free functions and inherent methods.
2015-02-25 22:05:07 +02:00
ast::ItemFn(decl, unsafety, constness, abi, generics, body) => {
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
let (rewritten_fn_decl, rewritten_body)
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
= expand_and_rename_fn_decl_and_block(decl, body, fld);
Refactored syntax::fold. Prior to this, the code there had a few issues: - Default implementations inconsistently either had the prefix `noop_` or not. - Some default methods where implemented in terms of a public noop function for user code to call, others where implemented directly on the trait and did not allow users of the trait to reuse the code. - Some of the default implementations where private, and thus not reusable for other implementors. - There where some bugs where default implementations called other default implementations directly, rather than to the underlying Folder, with the result of some AST nodes never being visited even if the user implemented that method. (For example, the current Folder never folded struct fields) This commit solves this situation somewhat radically by making _all_ `fold_...` functions in the module into Folder methods, and implementing them all in terms of public `noop_...` functions for other implementors to call out to. Some public functions had to be renamed to fit the new system, so this is a breaking change. [breaking-change]
2014-07-25 21:00:33 +02:00
let expanded_generics = fold::noop_fold_generics(generics,fld);
syntax: parse `const fn` for free functions and inherent methods.
2015-02-25 22:05:07 +02:00
ast::ItemFn(rewritten_fn_decl, unsafety, constness, abi,
expanded_generics, rewritten_body)
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
_ => noop_fold_item_underscore(item, fld)
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
}
}
Rename macro_escape to macro_use In the future we want to support #[macro_use(foo, bar)] mod macros; but it's not an essential part of macro reform. Reserve the syntax for now.
2014-12-18 20:48:26 -08:00
// does this attribute list contain "macro_use" ?
fn contains_macro_use(fld: &mut MacroExpander, attrs: &[ast::Attribute]) -> bool {
`for x in xs.iter()` -> `for x in &xs`
2015-01-31 12:20:46 -05:00
for attr in attrs {
Rename macro_escape to macro_use In the future we want to support #[macro_use(foo, bar)] mod macros; but it's not an essential part of macro reform. Reserve the syntax for now.
2014-12-18 20:48:26 -08:00
let mut is_use = attr.check_name("macro_use");
if attr.check_name("macro_escape") {
fld.cx.span_warn(attr.span, "macro_escape is a deprecated synonym for macro_use");
is_use = true;
if let ast::AttrInner = attr.node.style {
Change span_help calls to fileline_help where appropriate
2015-02-24 16:07:54 +02:00
fld.cx.fileline_help(attr.span, "consider an outer attribute, \
Rename macro_escape to macro_use In the future we want to support #[macro_use(foo, bar)] mod macros; but it's not an essential part of macro reform. Reserve the syntax for now.
2014-12-18 20:48:26 -08:00
#[macro_use] mod ...");
}
};
if is_use {
match attr.node.value.node {
ast::MetaWord(..) => (),
_ => fld.cx.span_err(attr.span, "arguments to macro_use are not allowed here"),
}
return true;
}
}
false
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
}
Rename `#mod` -> `#module` to not collide with the keyword.
2012-07-27 11:19:21 -07:00
// Support for item-position macro invocations, exactly the same
// logic as for expression-position macro invocations.
Add a special macro nonterminal $crate
2014-09-15 18:27:28 -07:00
pub fn expand_item_mac(it: P<ast::Item>,
fld: &mut MacroExpander) -> SmallVector<P<ast::Item>> {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let (extname, path_span, tts) = match it.node {
libsyntax: Renamed types, traits and enum variants to CamelCase.
2014-01-09 15:05:33 +02:00
ItemMac(codemap::Spanned {
Simplify and rename macro API Now that procedural macros can be implemented outside of the compiler, it's more important to have a reasonable API to work with. Here are the basic changes: * Rename SyntaxExpanderTTTrait to MacroExpander, SyntaxExpanderTT to BasicMacroExpander, etc. I think "procedural macro" is the right term for these now, right? The other option would be SynExtExpander or something like that. * Stop passing the SyntaxContext to extensions. This was only ever used by macro_rules, which doesn't even use it anymore. I can't think of a context in which an external extension would need it, and removal allows the API to be significantly simpler - no more SyntaxExpanderTTItemExpanderWithoutContext wrappers to worry about.
2014-01-25 13:34:26 -08:00
node: MacInvocTT(ref pth, ref tts, _),
Register new snapshots
2013-11-28 12:22:53 -08:00
..
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}) => {
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
(pth.segments[0].identifier, pth.span, (*tts).clone())
syntax: convert ast::spanned into a struct
2012-12-27 14:36:00 -05:00
}
Stop passing duplicate parameters in expand
2013-12-27 17:43:01 -07:00
_ => fld.cx.span_bug(it.span, "invalid item macro invocation")
syntax: remove most code handling old-style syntax extensions.
2012-12-12 12:25:40 -08:00
};
Use `biased_match!` to avoid over-deep indentation in expand.rs.
2012-11-17 07:41:36 -05:00
Refactored ast_map and friends, mainly to have Paths without storing them.
2014-02-14 07:07:09 +02:00
let extnamestr = token::get_ident(extname);
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
let fm = fresh_mark();
Replace LetSyntaxTT with MacroRulesTT The implementation of LetSyntaxTT was specialized to macro_rules! in various ways. This gets rid of the false generality and simplifies the code.
2014-09-15 16:09:09 -07:00
let items = {
let expanded = match fld.cx.syntax_env.find(&extname.name) {
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
None => {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fld.cx.span_err(path_span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("macro undefined: '{}!'",
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
extnamestr));
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
// let compilation continue
return SmallVector::zero();
}
Use `biased_match!` to avoid over-deep indentation in expand.rs.
2012-11-17 07:41:36 -05:00
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
Some(rc) => match *rc {
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
NormalTT(ref expander, span, allow_internal_unstable) => {
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
if it.ident.name != parse::token::special_idents::invalid.name {
fld.cx
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
.span_err(path_span,
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
&format!("macro {}! expects no ident argument, given '{}'",
extnamestr,
token::get_ident(it.ident)));
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
return SmallVector::zero();
}
fld.cx.bt_push(ExpnInfo {
call_site: it.span,
callee: NameAndSpan {
Libsyntax has been updated
2015-02-03 23:31:06 +01:00
name: extnamestr.to_string(),
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
format: MacroBang,
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
span: span,
allow_internal_unstable: allow_internal_unstable,
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
}
});
// mark before expansion:
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
let marked_before = mark_tts(&tts[..], fm);
expander.expand(fld.cx, it.span, &marked_before[..])
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
}
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
IdentTT(ref expander, span, allow_internal_unstable) => {
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
if it.ident.name == parse::token::special_idents::invalid.name {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fld.cx.span_err(path_span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("macro {}! expects an ident argument",
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
&extnamestr));
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
return SmallVector::zero();
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
}
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
fld.cx.bt_push(ExpnInfo {
call_site: it.span,
callee: NameAndSpan {
Libsyntax has been updated
2015-02-03 23:31:06 +01:00
name: extnamestr.to_string(),
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
format: MacroBang,
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
span: span,
allow_internal_unstable: allow_internal_unstable,
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
}
});
// mark before expansion:
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
let marked_tts = mark_tts(&tts[..], fm);
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
expander.expand(fld.cx, it.span, it.ident, marked_tts)
Get rid of structural records in libsyntax and the last bit in librustc.
2013-02-21 00:16:31 -08:00
}
Replace LetSyntaxTT with MacroRulesTT The implementation of LetSyntaxTT was specialized to macro_rules! in various ways. This gets rid of the false generality and simplifies the code.
2014-09-15 16:09:09 -07:00
MacroRulesTT => {
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
if it.ident.name == parse::token::special_idents::invalid.name {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fld.cx.span_err(path_span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("macro_rules! expects an ident argument")
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
);
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
return SmallVector::zero();
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
}
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
fld.cx.bt_push(ExpnInfo {
call_site: it.span,
callee: NameAndSpan {
Libsyntax has been updated
2015-02-03 23:31:06 +01:00
name: extnamestr.to_string(),
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
format: MacroBang,
Replace LetSyntaxTT with MacroRulesTT The implementation of LetSyntaxTT was specialized to macro_rules! in various ways. This gets rid of the false generality and simplifies the code.
2014-09-15 16:09:09 -07:00
span: None,
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
// `macro_rules!` doesn't directly allow
// unstable (this is orthogonal to whether
// the macro it creates allows it)
allow_internal_unstable: false,
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
}
});
Replace LetSyntaxTT with MacroRulesTT The implementation of LetSyntaxTT was specialized to macro_rules! in various ways. This gets rid of the false generality and simplifies the code.
2014-09-15 16:09:09 -07:00
// DON'T mark before expansion.
Reformat metadata for exported macros Instead of copy-pasting the whole macro_rules! item from the original .rs file, we serialize a separate name, attributes list, and body, the latter as pretty-printed TTs. The compilation of macro_rules! macros is decoupled somewhat from the expansion of macros in item position. This filters out comments, and facilitates selective imports.
2014-12-30 19:10:46 -08:00
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
let allow_internal_unstable = attr::contains_name(&it.attrs,
"allow_internal_unstable");
// ensure any #[allow_internal_unstable]s are
// detected (including nested macro definitions
// etc.)
if allow_internal_unstable && !fld.cx.ecfg.enable_allow_internal_unstable() {
feature_gate::emit_feature_err(
&fld.cx.parse_sess.span_diagnostic,
"allow_internal_unstable",
it.span,
feature_gate::EXPLAIN_ALLOW_INTERNAL_UNSTABLE)
}
Reformat metadata for exported macros Instead of copy-pasting the whole macro_rules! item from the original .rs file, we serialize a separate name, attributes list, and body, the latter as pretty-printed TTs. The compilation of macro_rules! macros is decoupled somewhat from the expansion of macros in item position. This filters out comments, and facilitates selective imports.
2014-12-30 19:10:46 -08:00
let def = ast::MacroDef {
ident: it.ident,
attrs: it.attrs.clone(),
id: ast::DUMMY_NODE_ID,
span: it.span,
imported_from: None,
cleanup: replace `as[_mut]_slice()` calls with deref coercions
2015-02-01 21:53:25 -05:00
export: attr::contains_name(&it.attrs, "macro_export"),
Allow selective macro import
2015-01-02 12:50:45 -08:00
use_locally: true,
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
allow_internal_unstable: allow_internal_unstable,
Reformat metadata for exported macros Instead of copy-pasting the whole macro_rules! item from the original .rs file, we serialize a separate name, attributes list, and body, the latter as pretty-printed TTs. The compilation of macro_rules! macros is decoupled somewhat from the expansion of macros in item position. This filters out comments, and facilitates selective imports.
2014-12-30 19:10:46 -08:00
body: tts,
};
Move #[macro_reexport] to extern crate
2015-01-01 16:37:47 -08:00
fld.cx.insert_macro(def);
Replace LetSyntaxTT with MacroRulesTT The implementation of LetSyntaxTT was specialized to macro_rules! in various ways. This gets rid of the false generality and simplifies the code.
2014-09-15 16:09:09 -07:00
// macro_rules! has a side effect but expands to nothing.
fld.cx.bt_pop();
return SmallVector::zero();
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
}
_ => {
fld.cx.span_err(it.span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("{}! is not legal in item position",
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
&extnamestr));
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
return SmallVector::zero();
Get rid of structural records in libsyntax and the last bit in librustc.
2013-02-21 00:16:31 -08:00
}
introducing let-syntax The let-syntax expander is different in that it doesn't apply a mark to its token trees before expansion. This is used for macro_rules, and it's because macro_rules is essentially MTWT's let-syntax. You don't want to mark before expand sees let-syntax, because there's no "after" syntax to mark again. In some sense, the cleaner approach might be to introduce a new AST node that macro_rules expands into; this would make it clearer that the expansion of a macro is distinct from the addition of a new macro binding. This should work for now, though...
2014-07-07 09:54:08 -07:00
}
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
};
Replace LetSyntaxTT with MacroRulesTT The implementation of LetSyntaxTT was specialized to macro_rules! in various ways. This gets rid of the false generality and simplifies the code.
2014-09-15 16:09:09 -07:00
expanded.make_items()
Use `biased_match!` to avoid over-deep indentation in expand.rs.
2012-11-17 07:41:36 -05:00
};
Make it possible to invoke item macros without passing identifier arguments.
2012-11-08 23:12:45 -05:00
Replace LetSyntaxTT with MacroRulesTT The implementation of LetSyntaxTT was specialized to macro_rules! in various ways. This gets rid of the false generality and simplifies the code.
2014-09-15 16:09:09 -07:00
let items = match items {
Some(items) => {
Fallout from renaming
2014-09-14 20:27:36 -07:00
items.into_iter()
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
.map(|i| mark_item(i, fm))
Fallout from renaming
2014-09-14 20:27:36 -07:00
.flat_map(|i| fld.fold_item(i).into_iter())
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
.collect()
}
Replace LetSyntaxTT with MacroRulesTT The implementation of LetSyntaxTT was specialized to macro_rules! in various ways. This gets rid of the false generality and simplifies the code.
2014-09-15 16:09:09 -07:00
None => {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fld.cx.span_err(path_span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("non-item macro in item position: {}",
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
&extnamestr));
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
return SmallVector::zero();
syntax: unify all MacResult's into a single trait. There's now one unified way to return things from a macro, instead of being able to choose the `AnyMacro` trait or the `MRItem`/`MRExpr` variants of the `MacResult` enum. This does simplify the logic handling the expansions, but the biggest value of this is it makes macros in (for example) type position easier to implement, as there's this single thing to modify. By my measurements (using `-Z time-passes` on libstd and librustc etc.), this appears to have little-to-no impact on expansion speed. There are presumably larger costs than the small number of extra allocations and virtual calls this adds (notably, all `macro_rules!`-defined macros have not changed in behaviour, since they had to use the `AnyMacro` trait anyway).
2014-04-15 22:00:14 +10:00
}
Use `biased_match!` to avoid over-deep indentation in expand.rs.
2012-11-17 07:41:36 -05:00
};
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
Stop passing duplicate parameters in expand
2013-12-27 17:43:01 -07:00
fld.cx.bt_pop();
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
items
Plumbing and parsing for item-position macros.
2012-07-05 12:10:33 -07:00
}
expansion abstraction
2014-07-12 15:00:23 -07:00
/// Expand a stmt
Improves handling of statement macros. Statement macros are now treated somewhat like item macros, in that a statement macro can now expand into a series of statements, rather than just a single statement. This allows statement macros to be nested inside other kinds of macros and expand properly, where previously the expansion would only work when no nesting was present. See: src/test/run-pass/macro-stmt_macro_in_expr_macro.rs src/test/run-pass/macro-nested_stmt_macro.rs This changes the interface of the MacResult trait. make_stmt has become make_stmts and now returns a vector, rather than a single item. Plugin writers who were implementing MacResult will have breakage, as well as anyone using MacEager::stmt. See: src/libsyntax/ext/base.rs This also causes a minor difference in behavior to the diagnostics produced by certain malformed macros. See: src/test/compile-fail/macro-incomplete-parse.rs
2015-04-07 08:21:18 -05:00
fn expand_stmt(stmt: P<Stmt>, fld: &mut MacroExpander) -> SmallVector<P<Stmt>> {
let stmt = stmt.and_then(|stmt| stmt);
let (mac, style) = match stmt.node {
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
StmtMac(mac, style) => (mac, style),
Improves handling of statement macros. Statement macros are now treated somewhat like item macros, in that a statement macro can now expand into a series of statements, rather than just a single statement. This allows statement macros to be nested inside other kinds of macros and expand properly, where previously the expansion would only work when no nesting was present. See: src/test/run-pass/macro-stmt_macro_in_expr_macro.rs src/test/run-pass/macro-nested_stmt_macro.rs This changes the interface of the MacResult trait. make_stmt has become make_stmts and now returns a vector, rather than a single item. Plugin writers who were implementing MacResult will have breakage, as well as anyone using MacEager::stmt. See: src/libsyntax/ext/base.rs This also causes a minor difference in behavior to the diagnostics produced by certain malformed macros. See: src/test/compile-fail/macro-incomplete-parse.rs
2015-04-07 08:21:18 -05:00
_ => return expand_non_macro_stmt(stmt, fld)
syntax: remove most code handling old-style syntax extensions.
2012-12-12 12:25:40 -08:00
};
Improves handling of statement macros. Statement macros are now treated somewhat like item macros, in that a statement macro can now expand into a series of statements, rather than just a single statement. This allows statement macros to be nested inside other kinds of macros and expand properly, where previously the expansion would only work when no nesting was present. See: src/test/run-pass/macro-stmt_macro_in_expr_macro.rs src/test/run-pass/macro-nested_stmt_macro.rs This changes the interface of the MacResult trait. make_stmt has become make_stmts and now returns a vector, rather than a single item. Plugin writers who were implementing MacResult will have breakage, as well as anyone using MacEager::stmt. See: src/libsyntax/ext/base.rs This also causes a minor difference in behavior to the diagnostics produced by certain malformed macros. See: src/test/compile-fail/macro-incomplete-parse.rs
2015-04-07 08:21:18 -05:00
let maybe_new_items =
expand_mac_invoc(mac.and_then(|m| m), stmt.span,
|r| r.make_stmts(),
|stmts, mark| stmts.move_map(|m| mark_stmt(m, mark)),
fld);
Improves semicolon expansion efficiency, corrects bt_pop placement. Implements pop() on SmallVector, and uses it to expand the final semicolon in a statement macro expansion more efficiently. Corrects the placement of the call to fld.cx.bt_pop(). It must run unconditionally to reverse the corresponding push.
2015-04-10 21:50:23 -05:00
let mut fully_expanded = match maybe_new_items {
Improves handling of statement macros. Statement macros are now treated somewhat like item macros, in that a statement macro can now expand into a series of statements, rather than just a single statement. This allows statement macros to be nested inside other kinds of macros and expand properly, where previously the expansion would only work when no nesting was present. See: src/test/run-pass/macro-stmt_macro_in_expr_macro.rs src/test/run-pass/macro-nested_stmt_macro.rs This changes the interface of the MacResult trait. make_stmt has become make_stmts and now returns a vector, rather than a single item. Plugin writers who were implementing MacResult will have breakage, as well as anyone using MacEager::stmt. See: src/libsyntax/ext/base.rs This also causes a minor difference in behavior to the diagnostics produced by certain malformed macros. See: src/test/compile-fail/macro-incomplete-parse.rs
2015-04-07 08:21:18 -05:00
Some(stmts) => {
// Keep going, outside-in.
Moves expand_stmt's bt_pop so that it balances correctly.
2015-04-11 00:59:00 -05:00
let new_items = stmts.into_iter().flat_map(|s| {
Improves handling of statement macros. Statement macros are now treated somewhat like item macros, in that a statement macro can now expand into a series of statements, rather than just a single statement. This allows statement macros to be nested inside other kinds of macros and expand properly, where previously the expansion would only work when no nesting was present. See: src/test/run-pass/macro-stmt_macro_in_expr_macro.rs src/test/run-pass/macro-nested_stmt_macro.rs This changes the interface of the MacResult trait. make_stmt has become make_stmts and now returns a vector, rather than a single item. Plugin writers who were implementing MacResult will have breakage, as well as anyone using MacEager::stmt. See: src/libsyntax/ext/base.rs This also causes a minor difference in behavior to the diagnostics produced by certain malformed macros. See: src/test/compile-fail/macro-incomplete-parse.rs
2015-04-07 08:21:18 -05:00
fld.fold_stmt(s).into_iter()
Moves expand_stmt's bt_pop so that it balances correctly.
2015-04-11 00:59:00 -05:00
}).collect();
fld.cx.bt_pop();
new_items
Use `biased_match!` to avoid over-deep indentation in expand.rs.
2012-11-17 07:41:36 -05:00
}
Improves handling of statement macros. Statement macros are now treated somewhat like item macros, in that a statement macro can now expand into a series of statements, rather than just a single statement. This allows statement macros to be nested inside other kinds of macros and expand properly, where previously the expansion would only work when no nesting was present. See: src/test/run-pass/macro-stmt_macro_in_expr_macro.rs src/test/run-pass/macro-nested_stmt_macro.rs This changes the interface of the MacResult trait. make_stmt has become make_stmts and now returns a vector, rather than a single item. Plugin writers who were implementing MacResult will have breakage, as well as anyone using MacEager::stmt. See: src/libsyntax/ext/base.rs This also causes a minor difference in behavior to the diagnostics produced by certain malformed macros. See: src/test/compile-fail/macro-incomplete-parse.rs
2015-04-07 08:21:18 -05:00
None => SmallVector::zero()
Respect semicolons always when expanding statments.
2012-11-21 18:49:42 -05:00
};
Improves handling of statement macros. Statement macros are now treated somewhat like item macros, in that a statement macro can now expand into a series of statements, rather than just a single statement. This allows statement macros to be nested inside other kinds of macros and expand properly, where previously the expansion would only work when no nesting was present. See: src/test/run-pass/macro-stmt_macro_in_expr_macro.rs src/test/run-pass/macro-nested_stmt_macro.rs This changes the interface of the MacResult trait. make_stmt has become make_stmts and now returns a vector, rather than a single item. Plugin writers who were implementing MacResult will have breakage, as well as anyone using MacEager::stmt. See: src/libsyntax/ext/base.rs This also causes a minor difference in behavior to the diagnostics produced by certain malformed macros. See: src/test/compile-fail/macro-incomplete-parse.rs
2015-04-07 08:21:18 -05:00
// If this is a macro invocation with a semicolon, then apply that
// semicolon to the final statement produced by expansion.
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
if style == MacStmtWithSemicolon {
Simplifications to statement macro handling. SmallVector::pop no longer worries about converting a Many repr downward to One or Zero. expand_stmt makes use of `if let` for style purposes.
2015-04-10 23:06:34 -05:00
if let Some(stmt) = fully_expanded.pop() {
let new_stmt = stmt.map(|Spanned {node, span}| {
Spanned {
node: match node {
StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id),
_ => node /* might already have a semi */
},
span: span
}
});
fully_expanded.push(new_stmt);
Improves semicolon expansion efficiency, corrects bt_pop placement. Implements pop() on SmallVector, and uses it to expand the final semicolon in a statement macro expansion more efficiently. Corrects the placement of the call to fld.cx.bt_pop(). It must run unconditionally to reverse the corresponding push.
2015-04-10 21:50:23 -05:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
}
Improves semicolon expansion efficiency, corrects bt_pop placement. Implements pop() on SmallVector, and uses it to expand the final semicolon in a statement macro expansion more efficiently. Corrects the placement of the call to fld.cx.bt_pop(). It must run unconditionally to reverse the corresponding push.
2015-04-10 21:50:23 -05:00
fully_expanded
Make it possible to expand stmt macros.
2012-11-19 20:31:22 -05:00
}
add hygiene support fns, move them around. also adds test cases
2013-06-25 11:40:51 -07:00
// expand a non-macro stmt. this is essentially the fallthrough for
// expand_stmt, above.
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn expand_non_macro_stmt(Spanned {node, span: stmt_span}: Stmt, fld: &mut MacroExpander)
-> SmallVector<P<Stmt>> {
add hygiene support fns, move them around. also adds test cases
2013-06-25 11:40:51 -07:00
// is it a let?
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
match node {
StmtDecl(decl, node_id) => decl.and_then(|Spanned {node: decl, span}| match decl {
DeclLocal(local) => {
// take it apart:
let rewritten_local = local.map(|Local {id, pat, ty, init, source, span}| {
libsyntax: Don't ICE on macro invocation in count expr of fixed array type.
2014-07-19 00:06:43 -07:00
// expand the ty since TyFixedLengthVec contains an Expr
// and thus may have a macro use
Make type in ast::Local optional
2015-01-02 20:55:31 +09:00
let expanded_ty = ty.map(|t| fld.fold_ty(t));
hygiene for match-bound vars now implemented Closes #9384
2014-06-26 16:49:13 -07:00
// expand the pat (it might contain macro uses):
librustc: Remove `@` pointer patterns from the language
2014-01-03 15:08:48 -08:00
let expanded_pat = fld.fold_pat(pat);
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
// find the PatIdents in the pattern:
librustc: Remove `@` pointer patterns from the language
2014-01-03 15:08:48 -08:00
// oh dear heaven... this is going to include the enum
// names, as well... but that should be okay, as long as
// the new names are gensyms for the old ones.
// generate fresh names, push them to a new pending list
librustc: Remove cross-borrowing of `Box<T>` to `&T` from the language, except where trait objects are involved. Part of issue #15349, though I'm leaving it open for trait objects. Cross borrowing for trait objects remains because it is needed until we have DST. This will break code like: fn foo(x: &int) { ... } let a = box 3i; foo(a); Change this code to: fn foo(x: &int) { ... } let a = box 3i; foo(&*a); [breaking-change]
2014-07-07 16:35:15 -07:00
let idents = pattern_bindings(&*expanded_pat);
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
let mut new_pending_renames =
idents.iter().map(|ident| (*ident, fresh_name(ident))).collect();
hygiene for match-bound vars now implemented Closes #9384
2014-06-26 16:49:13 -07:00
// rewrite the pattern using the new names (the old
// ones have already been applied):
librustc: Remove `@` pointer patterns from the language
2014-01-03 15:08:48 -08:00
let rewritten_pat = {
hygiene for match-bound vars now implemented Closes #9384
2014-06-26 16:49:13 -07:00
// nested binding to allow borrow to expire:
let mut rename_fld = IdentRenamer{renames: &mut new_pending_renames};
librustc: Remove `@` pointer patterns from the language
2014-01-03 15:08:48 -08:00
rename_fld.fold_pat(expanded_pat)
};
// add them to the existing pending renames:
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
fld.cx.syntax_env.info().pending_renames
Removed many pointless calls to *iter() and iter_mut()
2015-06-10 17:22:20 +01:00
.extend(new_pending_renames);
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
Local {
id: id,
ty: expanded_ty,
pat: rewritten_pat,
// also, don't forget to expand the init:
init: init.map(|e| fld.fold_expr(e)),
source: source,
librustc: Remove `@` pointer patterns from the language
2014-01-03 15:08:48 -08:00
span: span
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
}
});
SmallVector::one(P(Spanned {
node: StmtDecl(P(Spanned {
node: DeclLocal(rewritten_local),
span: span
}),
node_id),
span: stmt_span
}))
Rewrite SyntaxEnv I'd really like to be able to do something like struct MapChain<'next, K, V> { info: BlockInfo, map: HashMap<K, V>, next: Option<&'next mut MapChain<'next, K, V> } but I can't get the lifetimes to work out.
2013-12-30 17:45:39 -08:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
_ => {
noop_fold_stmt(Spanned {
node: StmtDecl(P(Spanned {
node: decl,
span: span
}),
node_id),
span: stmt_span
}, fld)
}
}),
_ => {
noop_fold_stmt(Spanned {
node: node,
span: stmt_span
}, fld)
}
add hygiene support fns, move them around. also adds test cases
2013-06-25 11:40:51 -07:00
}
}
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
// expand the arm of a 'match', renaming for macro hygiene
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn expand_arm(arm: ast::Arm, fld: &mut MacroExpander) -> ast::Arm {
hygiene for match-bound vars now implemented Closes #9384
2014-06-26 16:49:13 -07:00
// expand pats... they might contain macro uses:
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let expanded_pats = arm.pats.move_map(|pat| fld.fold_pat(pat));
Positive case of `len()` -> `is_empty()` `s/(?<!\{ self)(?<=\.)len\(\) == 0/is_empty()/g`
2015-03-24 16:53:34 -07:00
if expanded_pats.is_empty() {
Rename fail! to panic! https://github.com/rust-lang/rfcs/pull/221 The current terminology of "task failure" often causes problems when writing or speaking about code. You often want to talk about the possibility of an operation that returns a Result "failing", but cannot because of the ambiguity with task failure. Instead, you have to speak of "the failing case" or "when the operation does not succeed" or other circumlocutions. Likewise, we use a "Failure" header in rustdoc to describe when operations may fail the task, but it would often be helpful to separate out a section describing the "Err-producing" case. We have been steadily moving away from task failure and toward Result as an error-handling mechanism, so we should optimize our terminology accordingly: Result-producing functions should be easy to describe. To update your code, rename any call to `fail!` to `panic!` instead. Assuming you have not created your own macro named `panic!`, this will work on UNIX based systems: grep -lZR 'fail!' . | xargs -0 -l sed -i -e 's/fail!/panic!/g' You can of course also do this by hand. [breaking-change]
2014-10-09 15:17:22 -04:00
panic!("encountered match arm with 0 patterns");
working on hygiene
2014-06-25 15:20:01 -07:00
}
WIP match hygiene, compiles
2014-06-26 13:19:34 -07:00
// all of the pats must have the same set of bindings, so use the
// first one to extract them and generate new names:
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
let idents = pattern_bindings(&*expanded_pats[0]);
Fallout from renaming
2014-09-14 20:27:36 -07:00
let new_renames = idents.into_iter().map(|id| (id, fresh_name(&id))).collect();
use PatIdentRenamer for match bindings
2014-07-04 12:15:24 -07:00
// apply the renaming, but only to the PatIdents:
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
let mut rename_pats_fld = PatIdentRenamer{renames:&new_renames};
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let rewritten_pats = expanded_pats.move_map(|pat| rename_pats_fld.fold_pat(pat));
hygiene for match-bound vars now implemented Closes #9384
2014-06-26 16:49:13 -07:00
// apply renaming and then expansion to the guard and the body:
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
let mut rename_fld = IdentRenamer{renames:&new_renames};
hygiene for match-bound vars now implemented Closes #9384
2014-06-26 16:49:13 -07:00
let rewritten_guard =
arm.guard.map(|g| fld.fold_expr(rename_fld.fold_expr(g)));
let rewritten_body = fld.fold_expr(rename_fld.fold_expr(arm.body));
WIP match hygiene, compiles
2014-06-26 13:19:34 -07:00
ast::Arm {
syntax::fold: Allow removing attributes
2015-02-09 09:01:15 -08:00
attrs: fold::fold_attrs(arm.attrs, fld),
hygiene for match-bound vars now implemented Closes #9384
2014-06-26 16:49:13 -07:00
pats: rewritten_pats,
guard: rewritten_guard,
body: rewritten_body,
remove trailing whitespace
2014-06-26 16:53:33 -07:00
}
working on hygiene
2014-06-25 15:20:01 -07:00
}
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
/// A visitor that extracts the PatIdent (binding) paths
/// from a given thingy and puts them in a mutable
/// array
sed -i -s 's/#\[deriving(/#\[derive(/g' **/*.rs
2015-01-03 22:54:18 -05:00
#[derive(Clone)]
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
struct PatIdentFinder {
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
ident_accumulator: Vec<ast::Ident>
librustc: Introduce a new visitor type based on traits and port syntax to it. This is preparation for removing `@fn`. This does *not* use default methods yet, because I don't know whether they work. If they do, a forthcoming PR will use them. This also changes the precedence of `as`.
2013-07-19 18:42:11 -07:00
}
Track the visited AST's lifetime throughout Visitor.
2014-09-10 01:54:36 +03:00
impl<'v> Visitor<'v> for PatIdentFinder {
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
fn visit_pat(&mut self, pattern: &ast::Pat) {
librustc: Introduce a new visitor type based on traits and port syntax to it. This is preparation for removing `@fn`. This does *not* use default methods yet, because I don't know whether they work. If they do, a forthcoming PR will use them. This also changes the precedence of `as`.
2013-07-19 18:42:11 -07:00
match *pattern {
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
ast::Pat { id: _, node: ast::PatIdent(_, ref path1, ref inner), span: _ } => {
Simplify PatIdent to contain an Ident rather than a Path Rationale: for what appear to be historical reasons only, the PatIdent contains a Path rather than an Ident. This means that there are many places in the code where an ident is artificially promoted to a path, and---much more problematically--- a bunch of elements from a path are simply thrown away, which seems like an invitation to some really nasty bugs. This commit replaces the Path in a PatIdent with a SpannedIdent, which just contains an ident and a span.
2014-06-30 18:02:14 -07:00
self.ident_accumulator.push(path1.node);
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
// visit optional subpattern of PatIdent:
`for x in xs.iter()` -> `for x in &xs`
2015-01-31 12:20:46 -05:00
if let Some(ref subpat) = *inner {
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
self.visit_pat(&**subpat)
add hygiene support functions
2013-06-04 14:56:33 -07:00
}
}
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
// use the default traversal for non-PatIdents
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
_ => visit::walk_pat(self, pattern)
librustc: Introduce a new visitor type based on traits and port syntax to it. This is preparation for removing `@fn`. This does *not* use default methods yet, because I don't know whether they work. If they do, a forthcoming PR will use them. This also changes the precedence of `as`.
2013-07-19 18:42:11 -07:00
}
}
}
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
/// find the PatIdent paths in a pattern
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
fn pattern_bindings(pat: &ast::Pat) -> Vec<ast::Ident> {
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
let mut name_finder = PatIdentFinder{ident_accumulator:Vec::new()};
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
name_finder.visit_pat(pat);
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
name_finder.ident_accumulator
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
}
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
/// find the PatIdent paths in a
fn fn_decl_arg_bindings(fn_decl: &ast::FnDecl) -> Vec<ast::Ident> {
let mut pat_idents = PatIdentFinder{ident_accumulator:Vec::new()};
`for x in xs.iter()` -> `for x in &xs`
2015-01-31 12:20:46 -05:00
for arg in &fn_decl.inputs {
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
pat_idents.visit_pat(&*arg.pat);
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
}
pat_idents.ident_accumulator
}
WIP: adding context to macros
2013-07-05 13:57:53 -07:00
// expand a block. pushes a new exts_frame, then calls expand_block_elts
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
pub fn expand_block(blk: P<Block>, fld: &mut MacroExpander) -> P<Block> {
add hygiene support fns, move them around. also adds test cases
2013-06-25 11:40:51 -07:00
// see note below about treatment of exts table
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
with_exts_frame!(fld.cx.syntax_env,false,
Stop passing duplicate parameters in expand
2013-12-27 17:43:01 -07:00
expand_block_elts(blk, fld))
add hygiene support fns, move them around. also adds test cases
2013-06-25 11:40:51 -07:00
}
WIP: adding context to macros
2013-07-05 13:57:53 -07:00
// expand the elements of a block.
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
pub fn expand_block_elts(b: P<Block>, fld: &mut MacroExpander) -> P<Block> {
syntax: fix fallout of merging ast::ViewItem into ast::Item.
2015-01-13 17:30:17 +02:00
b.map(|Block {id, stmts, expr, rules, span}| {
Fallout from renaming
2014-09-14 20:27:36 -07:00
let new_stmts = stmts.into_iter().flat_map(|x| {
get rid of needless wrapper function
2014-06-26 13:18:52 -07:00
// perform all pending renames
libsyntax -- combine two iter ops into one so that `fld` does not need to be mutably shared between them both
2014-02-07 17:28:07 -05:00
let renamed_stmt = {
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
get rid of needless wrapper function
2014-06-26 13:18:52 -07:00
let mut rename_fld = IdentRenamer{renames:pending_renames};
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
rename_fld.fold_stmt(x).expect_one("rename_fold didn't return one value")
libsyntax -- combine two iter ops into one so that `fld` does not need to be mutably shared between them both
2014-02-07 17:28:07 -05:00
};
get rid of needless wrapper function
2014-06-26 13:18:52 -07:00
// expand macros in the statement
Fallout from renaming
2014-09-14 20:27:36 -07:00
fld.fold_stmt(renamed_stmt).into_iter()
libsyntax -- combine two iter ops into one so that `fld` does not need to be mutably shared between them both
2014-02-07 17:28:07 -05:00
}).collect();
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let new_expr = expr.map(|x| {
let expr = {
let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
let mut rename_fld = IdentRenamer{renames:pending_renames};
rename_fld.fold_expr(x)
};
fld.fold_expr(expr)
});
Block {
id: fld.new_id(id),
stmts: new_stmts,
expr: new_expr,
rules: rules,
span: span
}
Box Block, fn_decl, variant and Ty in the AST, as they were inflating critical enum sizes.
2013-12-01 00:00:39 +02:00
})
add renaming and sctable funs
2013-05-17 09:41:04 -07:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
match p.node {
PatMac(_) => {}
_ => return noop_fold_pat(p, fld)
Expand macros in patterns
2014-05-19 13:59:35 -07:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
p.map(|ast::Pat {node, span, ..}| {
let (pth, tts) = match node {
PatMac(mac) => match mac.node {
MacInvocTT(pth, tts, _) => {
(pth, tts)
}
},
_ => unreachable!()
};
Omit integer suffix when unnecessary See PR # 21378 for context
2015-01-28 01:01:48 +00:00
if pth.segments.len() > 1 {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fld.cx.span_err(pth.span, "expected macro name without module separators");
return DummyResult::raw_pat(span);
Expand macros in patterns
2014-05-19 13:59:35 -07:00
}
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
let extname = pth.segments[0].identifier;
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let extnamestr = token::get_ident(extname);
let marked_after = match fld.cx.syntax_env.find(&extname.name) {
None => {
fld.cx.span_err(pth.span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("macro undefined: '{}!'",
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
extnamestr));
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
// let compilation continue
return DummyResult::raw_pat(span);
}
Expand macros in patterns
2014-05-19 13:59:35 -07:00
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
Some(rc) => match *rc {
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
NormalTT(ref expander, tt_span, allow_internal_unstable) => {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fld.cx.bt_push(ExpnInfo {
call_site: span,
callee: NameAndSpan {
Libsyntax has been updated
2015-02-03 23:31:06 +01:00
name: extnamestr.to_string(),
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
format: MacroBang,
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
span: tt_span,
allow_internal_unstable: allow_internal_unstable,
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
}
});
Expand macros in patterns
2014-05-19 13:59:35 -07:00
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let fm = fresh_mark();
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
let marked_before = mark_tts(&tts[..], fm);
syntax: use an index in CodeMap instead of Gc for ExpnInfo.
2014-09-17 19:01:33 +03:00
let mac_span = fld.cx.original_span();
Fallout from fixing Issue 25199. There are two interesting kinds of breakage illustrated here: 1. `Box<Trait>` in many contexts is treated as `Box<Trait + 'static>`, due to [RFC 599]. However, in a type like `&'a Box<Trait>`, the `Box<Trait>` type will be expanded to `Box<Trait + 'a>`, again due to [RFC 599]. This, combined with the fix to Issue 25199, leads to a borrowck problem due the combination of this function signature (in src/libstd/net/parser.rs): ```rust fn read_or<T>(&mut self, parsers: &mut [Box<FnMut(&mut Parser) -> Option<T>>]) -> Option<T>; ``` with this call site (again in src/libstd/net/parser.rs): ```rust fn read_ip_addr(&mut self) -> Option<IpAddr> { let ipv4_addr = |p: &mut Parser| p.read_ipv4_addr().map(|v4| IpAddr::V4(v4)); let ipv6_addr = |p: &mut Parser| p.read_ipv6_addr().map(|v6| IpAddr::V6(v6)); self.read_or(&mut [Box::new(ipv4_addr), Box::new(ipv6_addr)]) } ``` yielding borrowck errors like: ``` parser.rs:265:27: 265:69 error: borrowed value does not live long enough parser.rs:265 self.read_or(&mut [Box::new(ipv4_addr), Box::new(ipv6_addr)]) ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ``` (full log at: https://gist.github.com/pnkfelix/e2e80f1a71580f5d3103 ) The issue here is perhaps subtle: the `parsers` argument is inferred to be taking a slice of boxed objects with the implicit lifetime bound attached to the `self` parameter to `read_or`. Meanwhile, the fix to Issue 25199 (added in a forth-coming commit) is forcing us to assume that each boxed object may have a destructor that could refer to state of that lifetime, and *therefore* that inferred lifetime is required to outlive the boxed object itself. In this case, the relevant boxed object here is not going to make any such references; I believe it is just an artifact of how the expression was built that it is not assigned type: `Box<FnMut(&mut Parser) -> Option<T> + 'static>`. (i.e., mucking with the expression is probably one way to fix this problem). But the other way to fix it, adopted here, is to change the `read_or` method type to force make the (presumably-intended) `'static` bound explicit on the boxed `FnMut` object. (Note: this is still just the *first* example of breakage.) 2. In `macro_rules.rs`, the `TTMacroExpander` trait defines a method with signature: ```rust fn expand<'cx>(&self, cx: &'cx mut ExtCtxt, ...) -> Box<MacResult+'cx>; ``` taking a `&'cx mut ExtCtxt` as an argument and returning a `Box<MacResult'cx>`. The fix to Issue 25199 (added in aforementioned forth-coming commit) assumes that a value of type `Box<MacResult+'cx>` may, in its destructor, refer to a reference of lifetime `'cx`; thus the `'cx` lifetime is forced to outlive the returned value. Meanwhile, within `expand.rs`, the old code was doing: ```rust match expander.expand(fld.cx, ...).make_pat() { ... => immutable borrow of fld.cx ... } ``` The problem is that the `'cx` lifetime, inferred for the `expander.expand` call, has now been extended so that it has to outlive the temporary R-value returned by `expanded.expand`. But call is also reborrowing `fld.cx` *mutably*, which means that this reborrow must end before any immutable borrow of `fld.cx`; but there is one of those within the match body. (Note that the temporary R-values for the input expression to `match` all live as long as the whole `match` expression itself (see Issue #3511 and PR #11585). To address this, I moved the construction of the pat value into its own `let`-statement, so that the `Box<MacResult>` will only live for as long as the initializing expression for the `let`-statement, and thus allow the subsequent immutable borrow within the `match`. [RFC 599]: https://github.com/rust-lang/rfcs/blob/master/text/0599-default-object-bound.md
2015-05-08 14:48:26 +02:00
let pat = expander.expand(fld.cx,
mac_span,
&marked_before[..]).make_pat();
let expanded = match pat {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
Some(e) => e,
None => {
fld.cx.span_err(
pth.span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!(
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
"non-pattern macro in pattern position: {}",
Update to last version, remove "[]" as much as possible
2015-02-04 21:48:12 +01:00
&extnamestr
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
)
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
);
return DummyResult::raw_pat(span);
}
};
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
// mark after:
mark_pat(expanded,fm)
}
_ => {
fld.cx.span_err(span,
use slicing sugar
2015-01-07 11:58:31 -05:00
&format!("{}! is not legal in pattern position",
Remove remaining uses of `[]`. This time I tried to use deref coercions where possible.
2015-02-20 14:08:14 -05:00
&extnamestr));
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
return DummyResult::raw_pat(span);
}
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
};
Expand macros in patterns
2014-05-19 13:59:35 -07:00
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let fully_expanded =
fld.fold_pat(marked_after).node.clone();
fld.cx.bt_pop();
Expand macros in patterns
2014-05-19 13:59:35 -07:00
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
ast::Pat {
id: ast::DUMMY_NODE_ID,
node: fully_expanded,
span: span
}
})
Expand macros in patterns
2014-05-19 13:59:35 -07:00
}
comments only
2014-07-02 23:17:10 -07:00
/// A tree-folder that applies every rename in its (mutable) list
/// to every identifier, including both bindings and varrefs
/// (and lots of things that will turn out to be neither)
Make visible types public in rustc
2014-03-02 15:26:39 -08:00
pub struct IdentRenamer<'a> {
move RenameList to mtwt, add new_renames abstraction
2014-07-02 22:38:30 -07:00
renames: &'a mtwt::RenameList,
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
libsyntax: Renamed types, traits and enum variants to CamelCase.
2014-01-09 15:05:33 +02:00
impl<'a> Folder for IdentRenamer<'a> {
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
fn fold_ident(&mut self, id: Ident) -> Ident {
Ident {
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
name: id.name,
new_mark -> apply_mark, new_rename -> apply_rename
2014-07-03 14:38:59 -07:00
ctxt: mtwt::apply_renames(self.renames, id.ctxt),
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
}
Reserve the keyword 'macro'
2015-01-02 13:39:05 -08:00
fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
fold::noop_fold_mac(mac, self)
make walk/visit_mac opt-in only macros can expand into arbitrary items, exprs, etc. This means that using a default walker or folder on an AST before macro expansion is complete will miss things (the things that the macros expand into). As a partial fence against this, this commit moves the default traversal of macros into a separate procedure, and makes the default trait implementation signal an error. This means that Folders and Visitors can traverse macros if they want to, but they need to explicitly add an impl that calls the walk_mac or fold_mac procedure This should prevent problems down the road.
2014-07-09 14:48:12 -07:00
}
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
/// A tree-folder that applies every rename in its list to
/// the idents that are in PatIdent patterns. This is more narrowly
/// focused than IdentRenamer, and is needed for FnDecl,
/// where we want to rename the args but not the fn name or the generics etc.
pub struct PatIdentRenamer<'a> {
renames: &'a mtwt::RenameList,
}
impl<'a> Folder for PatIdentRenamer<'a> {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn fold_pat(&mut self, pat: P<ast::Pat>) -> P<ast::Pat> {
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
match pat.node {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
ast::PatIdent(..) => {},
_ => return noop_fold_pat(pat, self)
}
pat.map(|ast::Pat {id, node, span}| match node {
ast::PatIdent(binding_mode, Spanned{span: sp, node: ident}, sub) => {
let new_ident = Ident{name: ident.name,
ctxt: mtwt::apply_renames(self.renames, ident.ctxt)};
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
let new_node =
ast::PatIdent(binding_mode,
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
Spanned{span: self.new_span(sp), node: new_ident},
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
sub.map(|p| self.fold_pat(p)));
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
ast::Pat {
id: id,
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
node: new_node,
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
span: self.new_span(span)
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
}
},
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
_ => unreachable!()
})
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
Reserve the keyword 'macro'
2015-01-02 13:39:05 -08:00
fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
fold::noop_fold_mac(mac, self)
make walk/visit_mac opt-in only macros can expand into arbitrary items, exprs, etc. This means that using a default walker or folder on an AST before macro expansion is complete will miss things (the things that the macros expand into). As a partial fence against this, this commit moves the default traversal of macros into a separate procedure, and makes the default trait implementation signal an error. This means that Folders and Visitors can traverse macros if they want to, but they need to explicitly add an impl that calls the walk_mac or fold_mac procedure This should prevent problems down the road.
2014-07-09 14:48:12 -07:00
}
Fix macro backtraces. In addition add information about the macro doing the expansion, and move the printing of the expansion backtrace from codemap::span_to_str to the diagnostic code. The backtrace is now more verbose and includes information on the macro doing the expansion, in addition to the expansion site.
2012-02-04 18:37:24 -07:00
}
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
fn expand_annotatable(a: Annotatable,
fld: &mut MacroExpander)
-> SmallVector<Annotatable> {
let a = expand_item_multi_modifier(a, fld);
let mut decorator_items = SmallVector::zero();
let mut new_attrs = Vec::new();
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
expand_decorators(a.clone(), fld, &mut decorator_items, &mut new_attrs);
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
let mut new_items: SmallVector<Annotatable> = match a {
Annotatable::Item(it) => match it.node {
ast::ItemMac(..) => {
expand_item_mac(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
}
ast::ItemMod(_) | ast::ItemForeignMod(_) => {
let valid_ident =
it.ident.name != parse::token::special_idents::invalid.name;
if valid_ident {
fld.cx.mod_push(it.ident);
}
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
let macro_use = contains_macro_use(fld, &new_attrs[..]);
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
let result = with_exts_frame!(fld.cx.syntax_env,
macro_use,
noop_fold_item(it, fld));
if valid_ident {
fld.cx.mod_pop();
}
result.into_iter().map(|i| Annotatable::Item(i)).collect()
},
_ => {
let it = P(ast::Item {
attrs: new_attrs,
..(*it).clone()
});
noop_fold_item(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
}
},
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
Annotatable::TraitItem(it) => match it.node {
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
ast::MethodTraitItem(_, Some(_)) => SmallVector::one(it.map(|ti| ast::TraitItem {
id: ti.id,
ident: ti.ident,
attrs: ti.attrs,
node: match ti.node {
ast::MethodTraitItem(sig, Some(body)) => {
let (sig, body) = expand_and_rename_method(sig, body, fld);
ast::MethodTraitItem(sig, Some(body))
}
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
_ => unreachable!()
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
},
span: fld.new_span(ti.span)
})),
_ => fold::noop_fold_trait_item(it, fld)
}.into_iter().map(Annotatable::TraitItem).collect(),
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
Annotatable::ImplItem(ii) => {
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
expand_impl_item(ii, fld).into_iter().map(Annotatable::ImplItem).collect()
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
}
};
Replace uses of Decorator and Modifier
2015-01-20 20:28:36 +01:00
new_items.push_all(decorator_items);
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
new_items
}
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
// Partition a set of attributes into one kind of attribute, and other kinds.
macro_rules! partition {
($fn_name: ident, $variant: ident) => {
#[allow(deprecated)] // The `allow` is needed because the `Modifier` variant might be used.
fn $fn_name(attrs: &[ast::Attribute],
fld: &MacroExpander)
-> (Vec<ast::Attribute>, Vec<ast::Attribute>) {
attrs.iter().cloned().partition(|attr| {
match fld.cx.syntax_env.find(&intern(&attr.name())) {
Some(rc) => match *rc {
$variant(..) => true,
_ => false
},
_ => false
}
})
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
}
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
}
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
}
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
partition!(modifiers, Modifier);
partition!(multi_modifiers, MultiModifier);
#[allow(deprecated)] // The `allow` is needed because the `Decorator` variant is used.
fn expand_decorators(a: Annotatable,
fld: &mut MacroExpander,
decorator_items: &mut SmallVector<Annotatable>,
new_attrs: &mut Vec<ast::Attribute>)
{
for attr in a.attrs() {
let mname = attr.name();
match fld.cx.syntax_env.find(&intern(&mname)) {
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
Some(rc) => match *rc {
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
Decorator(ref dec) => {
attr::mark_used(&attr);
fld.cx.bt_push(ExpnInfo {
call_site: attr.span,
callee: NameAndSpan {
name: mname.to_string(),
format: MacroAttribute,
span: Some(attr.span),
// attributes can do whatever they like,
// for now.
allow_internal_unstable: true,
}
});
// we'd ideally decorator_items.push_all(expand_item(item, fld)),
// but that double-mut-borrows fld
let mut items: SmallVector<Annotatable> = SmallVector::zero();
dec.expand(fld.cx,
attr.span,
&attr.node.value,
&a.clone().expect_item(),
&mut |item| items.push(Annotatable::Item(item)));
decorator_items.extend(items.into_iter()
.flat_map(|ann| expand_annotatable(ann, fld).into_iter()));
fld.cx.bt_pop();
}
MultiDecorator(ref dec) => {
attr::mark_used(&attr);
fld.cx.bt_push(ExpnInfo {
call_site: attr.span,
callee: NameAndSpan {
name: mname.to_string(),
format: MacroAttribute,
span: Some(attr.span),
// attributes can do whatever they like,
// for now.
allow_internal_unstable: true,
}
});
// we'd ideally decorator_items.push_all(expand_annotatable(ann, fld)),
// but that double-mut-borrows fld
let mut items: SmallVector<Annotatable> = SmallVector::zero();
dec.expand(fld.cx,
attr.span,
&attr.node.value,
Let MultiItemDecorator take `&Annotatable` (fixes #25683)
2015-05-22 21:10:14 +05:30
&a,
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
&mut |ann| items.push(ann));
decorator_items.extend(items.into_iter()
.flat_map(|ann| expand_annotatable(ann, fld).into_iter()));
fld.cx.bt_pop();
}
_ => new_attrs.push((*attr).clone()),
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
},
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
_ => new_attrs.push((*attr).clone()),
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
}
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
}
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
}
fn expand_item_multi_modifier(mut it: Annotatable,
fld: &mut MacroExpander)
-> Annotatable {
let (modifiers, other_attrs) = multi_modifiers(it.attrs(), fld);
// Update the attrs, leave everything else alone. Is this mutation really a good idea?
it = it.fold_attrs(other_attrs);
if modifiers.is_empty() {
return it
}
`for x in xs.iter()` -> `for x in &xs`
2015-01-31 12:20:46 -05:00
for attr in &modifiers {
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
let mname = attr.name();
Update to last version, remove "[]" as much as possible
2015-02-04 21:48:12 +01:00
match fld.cx.syntax_env.find(&intern(&mname)) {
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
Some(rc) => match *rc {
MultiModifier(ref mac) => {
attr::mark_used(attr);
fld.cx.bt_push(ExpnInfo {
call_site: attr.span,
callee: NameAndSpan {
Libsyntax has been updated
2015-02-03 23:31:06 +01:00
name: mname.to_string(),
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
format: MacroAttribute,
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
span: Some(attr.span),
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
// attributes can do whatever they like,
// for now
allow_internal_unstable: true,
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
}
});
it = mac.expand(fld.cx, attr.span, &*attr.node.value, it);
fld.cx.bt_pop();
}
_ => unreachable!()
},
_ => unreachable!()
}
}
// Expansion may have added new ItemModifiers.
expand_item_multi_modifier(it, fld)
}
WIP refactor expansion of decorators and move derive to MultiDecorator
2015-04-28 17:34:39 +12:00
#[allow(deprecated)] // This is needed because the `ItemModifier` trait is used
fn expand_item_modifiers(mut it: P<ast::Item>,
fld: &mut MacroExpander)
-> P<ast::Item> {
// partition the attributes into ItemModifiers and others
let (modifiers, other_attrs) = modifiers(&it.attrs, fld);
// update the attrs, leave everything else alone. Is this mutation really a good idea?
it = P(ast::Item {
attrs: other_attrs,
..(*it).clone()
});
if modifiers.is_empty() {
let it = expand_item_multi_modifier(Annotatable::Item(it), fld);
return it.expect_item();
}
for attr in &modifiers {
let mname = attr.name();
match fld.cx.syntax_env.find(&intern(&mname)) {
Some(rc) => match *rc {
Modifier(ref mac) => {
attr::mark_used(attr);
fld.cx.bt_push(ExpnInfo {
call_site: attr.span,
callee: NameAndSpan {
name: mname.to_string(),
format: MacroAttribute,
span: Some(attr.span),
// attributes can do whatever they like,
// for now
allow_internal_unstable: true,
}
});
it = mac.expand(fld.cx, attr.span, &*attr.node.value, it);
fld.cx.bt_pop();
}
_ => unreachable!()
},
_ => unreachable!()
}
}
// Expansion may have added new ItemModifiers.
// It is possible, that an item modifier could expand to a multi-modifier or
// vice versa. In this case we will expand all modifiers before multi-modifiers,
// which might give an odd ordering. However, I think it is unlikely that the
// two kinds will be mixed, and old-style multi-modifiers are deprecated.
expand_item_modifiers(it, fld)
}
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
fn expand_impl_item(ii: P<ast::ImplItem>, fld: &mut MacroExpander)
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
-> SmallVector<P<ast::ImplItem>> {
match ii.node {
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
ast::MethodImplItem(..) => SmallVector::one(ii.map(|ii| ast::ImplItem {
id: ii.id,
ident: ii.ident,
attrs: ii.attrs,
vis: ii.vis,
node: match ii.node {
ast::MethodImplItem(sig, body) => {
let (sig, body) = expand_and_rename_method(sig, body, fld);
ast::MethodImplItem(sig, body)
}
_ => unreachable!()
},
span: fld.new_span(ii.span)
})),
ast::MacImplItem(_) => {
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
let (span, mac) = ii.and_then(|ii| match ii.node {
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
ast::MacImplItem(mac) => (ii.span, mac),
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
_ => unreachable!()
});
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
let maybe_new_items =
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
expand_mac_invoc(mac, span,
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
|r| r.make_impl_items(),
|meths, mark| meths.move_map(|m| mark_impl_item(m, mark)),
macro expansion for methods Closes #4621
2014-07-13 09:35:48 -07:00
fld);
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
match maybe_new_items {
Some(impl_items) => {
Fix #19734 (ICE)
2014-12-12 17:34:28 +01:00
// expand again if necessary
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
let new_items = impl_items.into_iter().flat_map(|ii| {
expand_impl_item(ii, fld).into_iter()
}).collect();
Fix #19734 (ICE)
2014-12-12 17:34:28 +01:00
fld.cx.bt_pop();
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
new_items
Fix #19734 (ICE)
2014-12-12 17:34:28 +01:00
}
macro expansion for methods Closes #4621
2014-07-13 09:35:48 -07:00
None => SmallVector::zero()
Fix #19734 (ICE)
2014-12-12 17:34:28 +01:00
}
refactor Method definition to make space for macros This change propagates to many locations, but because of the Macro Exterminator (or, more properly, the invariant that it protects), macro invocations can't occur downstream of expansion. This means that in librustc and librustdoc, extracting the desired field can simply assume that it can't be a macro invocation. Functions in ast_util abstract over this check.
2014-07-11 21:22:11 -07:00
}
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
_ => fold::noop_fold_impl_item(ii, fld)
syntax: move indirection around {Trait,Impl}Item, from within.
2015-03-05 04:48:54 +02:00
}
implement hygiene for method args
2014-07-04 11:24:28 -07:00
}
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
/// Given a fn_decl and a block and a MacroExpander, expand the fn_decl, then use the
/// PatIdents in its arguments to perform renaming in the FnDecl and
/// the block, returning both the new FnDecl and the new Block.
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn expand_and_rename_fn_decl_and_block(fn_decl: P<ast::FnDecl>, block: P<ast::Block>,
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
fld: &mut MacroExpander)
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
-> (P<ast::FnDecl>, P<ast::Block>) {
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
let expanded_decl = fld.fold_fn_decl(fn_decl);
librustc: Remove cross-borrowing of `Box<T>` to `&T` from the language, except where trait objects are involved. Part of issue #15349, though I'm leaving it open for trait objects. Cross borrowing for trait objects remains because it is needed until we have DST. This will break code like: fn foo(x: &int) { ... } let a = box 3i; foo(a); Change this code to: fn foo(x: &int) { ... } let a = box 3i; foo(&*a); [breaking-change]
2014-07-07 16:35:15 -07:00
let idents = fn_decl_arg_bindings(&*expanded_decl);
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
let renames =
idents.iter().map(|id : &ast::Ident| (*id,fresh_name(id))).collect();
// first, a renamer for the PatIdents, for the fn_decl:
let mut rename_pat_fld = PatIdentRenamer{renames: &renames};
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
let rewritten_fn_decl = rename_pat_fld.fold_fn_decl(expanded_decl);
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
// now, a renamer for *all* idents, for the body:
let mut rename_fld = IdentRenamer{renames: &renames};
let rewritten_body = fld.fold_block(rename_fld.fold_block(block));
(rewritten_fn_decl,rewritten_body)
}
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
fn expand_and_rename_method(sig: ast::MethodSig, body: P<ast::Block>,
fld: &mut MacroExpander)
-> (ast::MethodSig, P<ast::Block>) {
let (rewritten_fn_decl, rewritten_body)
= expand_and_rename_fn_decl_and_block(sig.decl, body, fld);
(ast::MethodSig {
generics: fld.fold_generics(sig.generics),
abi: sig.abi,
explicit_self: fld.fold_explicit_self(sig.explicit_self),
unsafety: sig.unsafety,
Make various fixes: - add feature gate - add basic tests - adjust parser to eliminate conflict between `const fn` and associated constants - allow `const fn` in traits/trait-impls, but forbid later in type check - correct some merge conflicts
2015-05-05 08:47:04 -04:00
constness: sig.constness,
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
decl: rewritten_fn_decl
}, rewritten_body)
}
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
/// A tree-folder that performs macro expansion
Implement generalized object and type parameter bounds (Fixes #16462)
2014-08-27 21:46:52 -04:00
pub struct MacroExpander<'a, 'b:'a> {
syntax: Switch field privacy as necessary
2014-03-27 15:39:48 -07:00
pub cx: &'a mut ExtCtxt<'b>,
Allow `Self` in impls.
2014-12-14 15:42:41 +13:00
}
impl<'a, 'b> MacroExpander<'a, 'b> {
pub fn new(cx: &'a mut ExtCtxt<'b>) -> MacroExpander<'a, 'b> {
Check uses of `Self` in impls in the compiler rather than during expansion Closes #23909
2015-04-03 17:13:52 +13:00
MacroExpander { cx: cx }
Allow `Self` in impls.
2014-12-14 15:42:41 +13:00
}
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
De-@ ParseSess uses.
2014-03-09 16:54:34 +02:00
impl<'a, 'b> Folder for MacroExpander<'a, 'b> {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn fold_expr(&mut self, expr: P<ast::Expr>) -> P<ast::Expr> {
Stop passing duplicate parameters in expand
2013-12-27 17:43:01 -07:00
expand_expr(expr, self)
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn fold_pat(&mut self, pat: P<ast::Pat>) -> P<ast::Pat> {
Expand macros in patterns
2014-05-19 13:59:35 -07:00
expand_pat(pat, self)
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn fold_item(&mut self, item: P<ast::Item>) -> SmallVector<P<ast::Item>> {
Check uses of `Self` in impls in the compiler rather than during expansion Closes #23909
2015-04-03 17:13:52 +13:00
expand_item(item, self)
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ {
hygiene for item fn args also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 12:19:15 -07:00
expand_item_underscore(item, self)
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn fold_stmt(&mut self, stmt: P<ast::Stmt>) -> SmallVector<P<ast::Stmt>> {
Improves handling of statement macros. Statement macros are now treated somewhat like item macros, in that a statement macro can now expand into a series of statements, rather than just a single statement. This allows statement macros to be nested inside other kinds of macros and expand properly, where previously the expansion would only work when no nesting was present. See: src/test/run-pass/macro-stmt_macro_in_expr_macro.rs src/test/run-pass/macro-nested_stmt_macro.rs This changes the interface of the MacResult trait. make_stmt has become make_stmts and now returns a vector, rather than a single item. Plugin writers who were implementing MacResult will have breakage, as well as anyone using MacEager::stmt. See: src/libsyntax/ext/base.rs This also causes a minor difference in behavior to the diagnostics produced by certain malformed macros. See: src/test/compile-fail/macro-incomplete-parse.rs
2015-04-07 08:21:18 -05:00
expand_stmt(stmt, self)
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
Make ast_fold take &mut self
2013-12-27 20:34:51 -07:00
fn fold_block(&mut self, block: P<Block>) -> P<Block> {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
expand_block(block, self)
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn fold_arm(&mut self, arm: ast::Arm) -> ast::Arm {
working on hygiene
2014-06-25 15:20:01 -07:00
expand_arm(arm, self)
}
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
fn fold_trait_item(&mut self, i: P<ast::TraitItem>) -> SmallVector<P<ast::TraitItem>> {
expand_annotatable(Annotatable::TraitItem(i), self)
.into_iter().map(|i| i.expect_trait_item()).collect()
Syntax extensions on trait and impl items. Allows modifiers to be used on methods, associated types, etc.
2014-12-02 10:07:41 -08:00
}
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
fn fold_impl_item(&mut self, i: P<ast::ImplItem>) -> SmallVector<P<ast::ImplItem>> {
expand_annotatable(Annotatable::ImplItem(i), self)
.into_iter().map(|i| i.expect_impl_item()).collect()
implement hygiene for method args
2014-07-04 11:24:28 -07:00
}
Make ast_fold take &mut self
2013-12-27 20:34:51 -07:00
fn new_span(&mut self, span: Span) -> Span {
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
new_span(self.cx, span)
}
syntax: make a macros-injection pass; conditionally define debug! to a noop based on cfg(debug). Macros can be conditionally defined because stripping occurs before macro expansion, but, the built-in macros were only added as part of the actual expansion process and so couldn't be stripped to have definitions conditional on cfg flags. debug! is defined conditionally in terms of the debug config, expanding to nothing unless the --cfg debug flag is passed (to be precise it expands to `if false { normal_debug!(...) }` so that they are still type checked, and to avoid unused variable lints).
2013-07-16 15:05:50 +10:00
}
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
fn new_span(cx: &ExtCtxt, sp: Span) -> Span {
/* this discards information in the case of macro-defining macros */
Span {
lo: sp.lo,
hi: sp.hi,
syntax: use an index in CodeMap instead of Gc for ExpnInfo.
2014-09-17 19:01:33 +03:00
expn_id: cx.backtrace(),
add PatIdentRenamer
2014-07-02 23:16:01 -07:00
}
}
libsyntax: Pass feature set in ExpansionConfig, not just enable_quotes.
2015-02-15 21:30:45 +01:00
pub struct ExpansionConfig<'feat> {
rustc: Remove CrateId and all related support This commit removes all support in the compiler for the #[crate_id] attribute and all of its derivative infrastructure. A list of the functionality removed is: * The #[crate_id] attribute no longer exists * There is no longer the concept of a version of a crate * Version numbers are no longer appended to symbol names * The --crate-id command line option has been removed To migrate forward, rename #[crate_id] to #[crate_name] and only the name of the crate itself should be mentioned. The version/path of the old crate id should be removed. For a transitionary state, the #[crate_id] attribute is still accepted if the #[crate_name] is not present, but it is warned about if it is the only identifier present. RFC: 0035-remove-crate-id [breaking-change]
2014-06-06 13:21:18 -07:00
pub crate_name: String,
libsyntax: Pass feature set in ExpansionConfig, not just enable_quotes.
2015-02-15 21:30:45 +01:00
pub features: Option<&'feat Features>,
libsyntax: uint types to usize
2015-01-17 23:33:05 +00:00
pub recursion_limit: usize,
Add "trace-macros" as a compiler flag Fixes #22619
2015-04-14 15:36:38 +02:00
pub trace_mac: bool,
Hide the quote_*! macros when the feature gate is off This makes it easier to experiment with improved quasiquoting as an ordinary plugin library. The list of quote macros in feature_gate.rs was already out of sync; this commit also prevents that problem in the future.
2014-09-26 17:14:23 -07:00
}
Consolidate ExpansionConfig feature tests
2015-03-06 12:56:28 -08:00
macro_rules! feature_tests {
($( fn $getter:ident = $field:ident, )*) => {
$(
pub fn $getter(&self) -> bool {
match self.features {
Some(&Features { $field: true, .. }) => true,
_ => false,
}
}
)*
}
}
libsyntax: Pass feature set in ExpansionConfig, not just enable_quotes.
2015-02-15 21:30:45 +01:00
impl<'feat> ExpansionConfig<'feat> {
pub fn default(crate_name: String) -> ExpansionConfig<'static> {
Hide the quote_*! macros when the feature gate is off This makes it easier to experiment with improved quasiquoting as an ordinary plugin library. The list of quote macros in feature_gate.rs was already out of sync; this commit also prevents that problem in the future.
2014-09-26 17:14:23 -07:00
ExpansionConfig {
crate_name: crate_name,
libsyntax: Pass feature set in ExpansionConfig, not just enable_quotes.
2015-02-15 21:30:45 +01:00
features: None,
Limit recursion depth for macro expansions, closes #17628
2014-10-01 11:38:54 +02:00
recursion_limit: 64,
Add "trace-macros" as a compiler flag Fixes #22619
2015-04-14 15:36:38 +02:00
trace_mac: false,
Hide the quote_*! macros when the feature gate is off This makes it easier to experiment with improved quasiquoting as an ordinary plugin library. The list of quote macros in feature_gate.rs was already out of sync; this commit also prevents that problem in the future.
2014-09-26 17:14:23 -07:00
}
}
libsyntax: Pass feature set in ExpansionConfig, not just enable_quotes.
2015-02-15 21:30:45 +01:00
Consolidate ExpansionConfig feature tests
2015-03-06 12:56:28 -08:00
feature_tests! {
fn enable_quotes = allow_quote,
fn enable_asm = allow_asm,
fn enable_log_syntax = allow_log_syntax,
fn enable_concat_idents = allow_concat_idents,
fn enable_trace_macros = allow_trace_macros,
fn enable_allow_internal_unstable = allow_internal_unstable,
Make #[derive(Anything)] into sugar for #[derive_Anything] This is a hack, but I don't think we can do much better as long as `derive` is running at the syntax expansion phase. If the custom_derive feature gate is enabled, this works with user-defined traits and syntax extensions. Without the gate, you can't use e.g. #[derive_Clone] directly, so this does not change the stable language. This commit also cleans up the deriving code somewhat, and forbids some previously-meaningless attribute syntax. For this reason it's technically a [breaking-change]
2015-03-06 13:15:54 -08:00
fn enable_custom_derive = allow_custom_derive,
Add #[allow_internal_unstable] to track stability for macros better. Unstable items used in a macro expansion will now always trigger stability warnings, *unless* the unstable items are directly inside a macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns unless the span of the unstable item is a subspan of the definition of a macro marked with that attribute. E.g. #[allow_internal_unstable] macro_rules! foo { ($e: expr) => {{ $e; unstable(); // no warning only_called_by_foo!(); }} } macro_rules! only_called_by_foo { () => { unstable() } // warning } foo!(unstable()) // warning The unstable inside `foo` is fine, due to the attribute. But the `unstable` inside `only_called_by_foo` is not, since that macro doesn't have the attribute, and the `unstable` passed into `foo` is also not fine since it isn't contained in the macro itself (that is, even though it is only used directly in the macro). In the process this makes the stability tracking much more precise, e.g. previously `println!("{}", unstable())` got no warning, but now it does. As such, this is a bug fix that may cause [breaking-change]s. The attribute is definitely feature gated, since it explicitly allows side-stepping the feature gating system.
2015-03-01 14:09:28 +11:00
}
syntax: Conditionally deriving(Hash) with Writers If #[feature(default_type_parameters)] is enabled for a crate, then deriving(Hash) will expand with Hash<W: Writer> instead of Hash<SipState> so more hash algorithms can be used.
2014-02-28 23:17:38 -08:00
}
libsyntax: Pass feature set in ExpansionConfig, not just enable_quotes.
2015-02-15 21:30:45 +01:00
pub fn expand_crate<'feat>(parse_sess: &parse::ParseSess,
cfg: ExpansionConfig<'feat>,
// these are the macros being imported to this crate:
imported_macros: Vec<ast::MacroDef>,
user_exts: Vec<NamedSyntaxExtension>,
c: Crate) -> Crate {
syntax: Conditionally deriving(Hash) with Writers If #[feature(default_type_parameters)] is enabled for a crate, then deriving(Hash) will expand with Hash<W: Writer> instead of Hash<SipState> so more hash algorithms can be used.
2014-02-28 23:17:38 -08:00
let mut cx = ExtCtxt::new(parse_sess, c.config.clone(), cfg);
Don't use std:: paths in syntax extensions when compiling a #![no_std] crate Fixes #16803. Fixes #14342. Fixes half of #21827 -- slice syntax is still broken.
2014-09-07 14:57:26 -07:00
cx.use_std = std_inject::use_std(&c);
Allow `Self` in impls.
2014-12-14 15:42:41 +13:00
let mut expander = MacroExpander::new(&mut cx);
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
`for x in xs.into_iter()` -> `for x in xs` Also `for x in option.into_iter()` -> `if let Some(x) = option`
2015-01-31 20:03:04 -05:00
for def in imported_macros {
Move #[macro_reexport] to extern crate
2015-01-01 16:37:47 -08:00
expander.cx.insert_macro(def);
Implement #[plugin_registrar] See RFC 22. [breaking-change]
2014-05-24 16:16:10 -07:00
}
`for x in xs.into_iter()` -> `for x in xs` Also `for x in option.into_iter()` -> `if let Some(x) = option`
2015-01-31 20:03:04 -05:00
for (name, extension) in user_exts {
Moved `syntax::ext::base::SyntaxEnv` into `syntax::ext::base::ExtCtx`
2014-07-19 21:34:24 +02:00
expander.cx.syntax_env.insert(name, extension);
Implement #[plugin_registrar] See RFC 22. [breaking-change]
2014-05-24 16:16:10 -07:00
}
use side table to store exported macros Per discussion with @sfackler, refactored the expander to change the way that exported macros are collected. Specifically, a crate now contains a side table of spans that exported macros go into. This has two benefits. First, the encoder doesn't need to scan through the expanded crate in order to discover exported macros. Second, the expander can drop all expanded macros from the crate, with the pleasant result that a fully expanded crate contains no macro invocations (which include macro definitions).
2014-07-10 15:41:11 -07:00
let mut ret = expander.fold_crate(c);
ret.exported_macros = expander.cx.exported_macros.clone();
Add initial support for a new formatting syntax The new macro is available under the name ifmt! (only an intermediate name)
2013-07-29 01:12:41 -07:00
parse_sess.span_diagnostic.handler().abort_if_errors();
return ret;
Move macro expansion to a separate phase, change macro syntax, and add parse_sess to session.
2011-07-06 15:22:23 -07:00
}
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
comment on hygienic context extension train fns
2013-07-13 10:18:37 -07:00
// HYGIENIC CONTEXT EXTENSION:
// all of these functions are for walking over
// ASTs and making some change to the context of every
// element that has one. a CtxtFn is a trait-ified
// version of a closure in (SyntaxContext -> SyntaxContext).
// the ones defined here include:
// Marker - add a mark to a context
Removed @self and @Trait.
2014-02-07 00:38:33 +02:00
// A Marker adds the given mark to the syntax context
struct Marker { mark: Mrk }
rework fold so that fold_tts takes an ast_fold rather than a thunk, stop using closures in ident traversal
2013-07-09 15:56:21 -07:00
Removed @self and @Trait.
2014-02-07 00:38:33 +02:00
impl Folder for Marker {
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
fn fold_ident(&mut self, id: Ident) -> Ident {
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
ast::Ident {
Removed @self and @Trait.
2014-02-07 00:38:33 +02:00
name: id.name,
new_mark -> apply_mark, new_rename -> apply_rename
2014-07-03 14:38:59 -07:00
ctxt: mtwt::apply_mark(self.mark, id.ctxt)
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
}
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn fold_mac(&mut self, Spanned {node, span}: ast::Mac) -> ast::Mac {
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
Spanned {
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
node: match node {
MacInvocTT(path, tts, ctxt) => {
MacInvocTT(self.fold_path(path),
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
self.fold_tts(&tts[..]),
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
mtwt::apply_mark(self.mark, ctxt))
}
},
span: span,
librustc: Change fold to use traits instead of `@fn`.
2013-08-29 12:10:02 -07:00
}
rework fold so that fold_tts takes an ast_fold rather than a thunk, stop using closures in ident traversal
2013-07-09 15:56:21 -07:00
}
}
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// apply a given mark to the given token trees. Used prior to expansion of a macro.
libsyntax: Mechanically change `~[T]` to `Vec<T>`
2014-02-28 13:09:09 -08:00
fn mark_tts(tts: &[TokenTree], m: Mrk) -> Vec<TokenTree> {
Refactored syntax::fold. Prior to this, the code there had a few issues: - Default implementations inconsistently either had the prefix `noop_` or not. - Some default methods where implemented in terms of a public noop function for user code to call, others where implemented directly on the trait and did not allow users of the trait to reuse the code. - Some of the default implementations where private, and thus not reusable for other implementors. - There where some bugs where default implementations called other default implementations directly, rather than to the underlying Folder, with the result of some AST nodes never being visited even if the user implemented that method. (For example, the current Folder never folded struct fields) This commit solves this situation somewhat radically by making _all_ `fold_...` functions in the module into Folder methods, and implementing them all in terms of public `noop_...` functions for other implementors to call out to. Some public functions had to be renamed to fit the new system, so this is a breaking change. [breaking-change]
2014-07-25 21:00:33 +02:00
noop_fold_tts(tts, &mut Marker{mark:m})
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
}
// apply a given mark to the given expr. Used following the expansion of a macro.
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn mark_expr(expr: P<ast::Expr>, m: Mrk) -> P<ast::Expr> {
remove unnecessary abstraction
2014-06-26 15:37:18 -07:00
Marker{mark:m}.fold_expr(expr)
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
}
Expand macros in patterns
2014-05-19 13:59:35 -07:00
// apply a given mark to the given pattern. Used following the expansion of a macro.
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn mark_pat(pat: P<ast::Pat>, m: Mrk) -> P<ast::Pat> {
remove unnecessary abstraction
2014-06-26 15:37:18 -07:00
Marker{mark:m}.fold_pat(pat)
Expand macros in patterns
2014-05-19 13:59:35 -07:00
}
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// apply a given mark to the given stmt. Used following the expansion of a macro.
Improves handling of statement macros. Statement macros are now treated somewhat like item macros, in that a statement macro can now expand into a series of statements, rather than just a single statement. This allows statement macros to be nested inside other kinds of macros and expand properly, where previously the expansion would only work when no nesting was present. See: src/test/run-pass/macro-stmt_macro_in_expr_macro.rs src/test/run-pass/macro-nested_stmt_macro.rs This changes the interface of the MacResult trait. make_stmt has become make_stmts and now returns a vector, rather than a single item. Plugin writers who were implementing MacResult will have breakage, as well as anyone using MacEager::stmt. See: src/libsyntax/ext/base.rs This also causes a minor difference in behavior to the diagnostics produced by certain malformed macros. See: src/test/compile-fail/macro-incomplete-parse.rs
2015-04-07 08:21:18 -05:00
fn mark_stmt(stmt: P<ast::Stmt>, m: Mrk) -> P<ast::Stmt> {
Marker{mark:m}.fold_stmt(stmt)
macro expansion for methods Closes #4621
2014-07-13 09:35:48 -07:00
.expect_one("marking a stmt didn't return exactly one stmt")
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
}
// apply a given mark to the given item. Used following the expansion of a macro.
syntax: fix fallout from using ptr::P.
2014-09-13 19:06:01 +03:00
fn mark_item(expr: P<ast::Item>, m: Mrk) -> P<ast::Item> {
remove unnecessary abstraction
2014-06-26 15:37:18 -07:00
Marker{mark:m}.fold_item(expr)
macro expansion for methods Closes #4621
2014-07-13 09:35:48 -07:00
.expect_one("marking an item didn't return exactly one item")
}
// apply a given mark to the given item. Used following the expansion of a macro.
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
fn mark_impl_item(ii: P<ast::ImplItem>, m: Mrk) -> P<ast::ImplItem> {
syntax: gather common fields of impl & trait items into their respective types.
2015-03-10 12:28:44 +02:00
Marker{mark:m}.fold_impl_item(ii)
syntax: move MethMac to MacImplItem and combine {Provided,Required}Method into MethodTraitItem.
2015-03-11 23:38:58 +02:00
.expect_one("marking an impl item didn't return exactly one impl item")
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
}
add Macro Exterminator the Macro Exterminator ensures that there are no macro invocations in an AST. This should help make later passes confident that there aren't hidden items, methods, expressions, etc.
2014-07-09 16:41:13 -07:00
/// Check that there are no macro invocations left in the AST:
pub fn check_for_macros(sess: &parse::ParseSess, krate: &ast::Crate) {
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
visit::walk_crate(&mut MacroExterminator{sess:sess}, krate);
add Macro Exterminator the Macro Exterminator ensures that there are no macro invocations in an AST. This should help make later passes confident that there aren't hidden items, methods, expressions, etc.
2014-07-09 16:41:13 -07:00
}
/// A visitor that ensures that no macro invocations remain in an AST.
struct MacroExterminator<'a>{
sess: &'a parse::ParseSess
}
Track the visited AST's lifetime throughout Visitor.
2014-09-10 01:54:36 +03:00
impl<'a, 'v> Visitor<'v> for MacroExterminator<'a> {
Reserve the keyword 'macro'
2015-01-02 13:39:05 -08:00
fn visit_mac(&mut self, mac: &ast::Mac) {
self.sess.span_diagnostic.span_bug(mac.span,
add Macro Exterminator the Macro Exterminator ensures that there are no macro invocations in an AST. This should help make later passes confident that there aren't hidden items, methods, expressions, etc.
2014-07-09 16:41:13 -07:00
"macro exterminator: expected AST \
with no macro invocations");
}
}
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
#[cfg(test)]
Change name of unit test sub-module to "tests". Changes the style guidelines regarding unit tests to recommend using a sub-module named "tests" instead of "test" for unit tests as "test" might clash with imports of libtest.
2015-04-24 17:30:41 +02:00
mod tests {
Test fixes and rebase conflicts
2015-01-07 18:53:58 -08:00
use super::{pattern_bindings, expand_crate};
Hide the quote_*! macros when the feature gate is off This makes it easier to experiment with improved quasiquoting as an ordinary plugin library. The list of quote macros in feature_gate.rs was already out of sync; this commit also prevents that problem in the future.
2014-09-26 17:14:23 -07:00
use super::{PatIdentFinder, IdentRenamer, PatIdentRenamer, ExpansionConfig};
Fix implicit leaks of imports throughout libraries Also touch up use of 'pub' and move some tests around so the tested functions don't have to be 'pub'
2013-02-25 14:11:21 -05:00
use ast;
fix #[cfg(test)] warnings
2015-01-26 22:56:50 -05:00
use ast::Name;
Fix implicit leaks of imports throughout libraries Also touch up use of 'pub' and move some tests around so the tested functions don't have to be 'pub'
2013-02-25 14:11:21 -05:00
use codemap;
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
use ext::mtwt;
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
use fold::Folder;
Fix implicit leaks of imports throughout libraries Also touch up use of 'pub' and move some tests around so the tested functions don't have to be 'pub'
2013-02-25 14:11:21 -05:00
use parse;
WIP: adding mark-cancelling for macro_rules
2013-07-14 15:25:04 -04:00
use parse::token;
De-@ ParseSess uses.
2014-03-09 16:54:34 +02:00
use util::parser_testing::{string_to_parser};
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
use util::parser_testing::{string_to_pat, string_to_crate, strs_to_idents};
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
use visit;
syntax: remove dead @mut Visitor impl (only used in tests). Also, move some code only uses in the tests into the test module, and replace some needless @mut ~[] with plain ~[].
2013-10-28 19:20:26 +11:00
use visit::Visitor;
// a visitor that extracts the paths
// from a given thingy and puts them in a mutable
// array (passed in to the traversal)
sed -i -s 's/#\[deriving(/#\[derive(/g' **/*.rs
2015-01-03 22:54:18 -05:00
#[derive(Clone)]
remove unneccessary pubs, shorten names
2014-06-24 17:03:49 -07:00
struct PathExprFinderContext {
libsyntax: Mechanically change `~[T]` to `Vec<T>`
2014-02-28 13:09:09 -08:00
path_accumulator: Vec<ast::Path> ,
syntax: remove dead @mut Visitor impl (only used in tests). Also, move some code only uses in the tests into the test module, and replace some needless @mut ~[] with plain ~[].
2013-10-28 19:20:26 +11:00
}
Track the visited AST's lifetime throughout Visitor.
2014-09-10 01:54:36 +03:00
impl<'v> Visitor<'v> for PathExprFinderContext {
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
fn visit_expr(&mut self, expr: &ast::Expr) {
Implement `<T>::method` UFCS expression syntax.
2015-02-17 19:29:13 +02:00
if let ast::ExprPath(None, ref p) = expr.node {
self.path_accumulator.push(p.clone());
syntax: remove dead @mut Visitor impl (only used in tests). Also, move some code only uses in the tests into the test module, and replace some needless @mut ~[] with plain ~[].
2013-10-28 19:20:26 +11:00
}
Implement `<T>::method` UFCS expression syntax.
2015-02-17 19:29:13 +02:00
visit::walk_expr(self, expr);
syntax: remove dead @mut Visitor impl (only used in tests). Also, move some code only uses in the tests into the test module, and replace some needless @mut ~[] with plain ~[].
2013-10-28 19:20:26 +11:00
}
}
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
// find the variable references in a crate
fn crate_varrefs(the_crate : &ast::Crate) -> Vec<ast::Path> {
let mut path_finder = PathExprFinderContext{path_accumulator:Vec::new()};
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
visit::walk_crate(&mut path_finder, the_crate);
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
path_finder.path_accumulator
syntax: remove dead @mut Visitor impl (only used in tests). Also, move some code only uses in the tests into the test module, and replace some needless @mut ~[] with plain ~[].
2013-10-28 19:20:26 +11:00
}
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
/// A Visitor that extracts the identifiers from a thingy.
// as a side note, I'm starting to want to abstract over these....
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
struct IdentFinder {
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
ident_accumulator: Vec<ast::Ident>
}
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
Track the visited AST's lifetime throughout Visitor.
2014-09-10 01:54:36 +03:00
impl<'v> Visitor<'v> for IdentFinder {
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
fn visit_ident(&mut self, _: codemap::Span, id: ast::Ident){
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
self.ident_accumulator.push(id);
}
}
/// Find the idents in a crate
fn crate_idents(the_crate: &ast::Crate) -> Vec<ast::Ident> {
let mut ident_finder = IdentFinder{ident_accumulator: Vec::new()};
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
visit::walk_crate(&mut ident_finder, the_crate);
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
ident_finder.ident_accumulator
}
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
// these following tests are quite fragile, in that they don't test what
// *kind* of failure occurs.
libsyntax: Pass feature set in ExpansionConfig, not just enable_quotes.
2015-02-15 21:30:45 +01:00
fn test_ecfg() -> ExpansionConfig<'static> {
Hide the quote_*! macros when the feature gate is off This makes it easier to experiment with improved quasiquoting as an ordinary plugin library. The list of quote macros in feature_gate.rs was already out of sync; this commit also prevents that problem in the future.
2014-09-26 17:14:23 -07:00
ExpansionConfig::default("test".to_string())
}
comments only
2014-06-23 18:45:51 -07:00
// make sure that macros can't escape fns
Rename #[should_fail] to #[should_panic]
2015-01-31 15:08:25 -08:00
#[should_panic]
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
#[test] fn macros_cant_escape_fns_test () {
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
let src = "fn bogus() {macro_rules! z (() => (3+4));}\
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
fn inty() -> i32 { z!() }".to_string();
syntax: refactor (Span)Handler and ParseSess constructors to be methods.
2015-05-13 23:00:17 +03:00
let sess = parse::ParseSess::new();
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
let crate_ast = parse::parse_crate_from_source_str(
std: Rename strbuf operations to string [breaking-change]
2014-05-25 03:17:19 -07:00
"<test>".to_string(),
Use @str instead of @~str in libsyntax and librustc. Fixes #5048. This almost removes the StringRef wrapper, since all strings are Equiv-alent now. Removes a lot of `/* bad */ copy *`'s, and converts several things to be &'static str (the lint table and the intrinsics table). There are many instances of .to_managed(), unfortunately.
2013-06-13 03:02:55 +10:00
src,
Fix rustdoc and tests.
2014-03-17 09:55:41 +02:00
Vec::new(), &sess);
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
// should fail:
Hide the quote_*! macros when the feature gate is off This makes it easier to experiment with improved quasiquoting as an ordinary plugin library. The list of quote macros in feature_gate.rs was already out of sync; this commit also prevents that problem in the future.
2014-09-26 17:14:23 -07:00
expand_crate(&sess,test_ecfg(),vec!(),vec!(),crate_ast);
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
}
comments only
2014-06-23 18:45:51 -07:00
// make sure that macros can't escape modules
Rename #[should_fail] to #[should_panic]
2015-01-31 15:08:25 -08:00
#[should_panic]
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
#[test] fn macros_cant_escape_mods_test () {
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
let src = "mod foo {macro_rules! z (() => (3+4));}\
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
fn inty() -> i32 { z!() }".to_string();
syntax: refactor (Span)Handler and ParseSess constructors to be methods.
2015-05-13 23:00:17 +03:00
let sess = parse::ParseSess::new();
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
let crate_ast = parse::parse_crate_from_source_str(
std: Rename strbuf operations to string [breaking-change]
2014-05-25 03:17:19 -07:00
"<test>".to_string(),
Use @str instead of @~str in libsyntax and librustc. Fixes #5048. This almost removes the StringRef wrapper, since all strings are Equiv-alent now. Removes a lot of `/* bad */ copy *`'s, and converts several things to be &'static str (the lint table and the intrinsics table). There are many instances of .to_managed(), unfortunately.
2013-06-13 03:02:55 +10:00
src,
Fix rustdoc and tests.
2014-03-17 09:55:41 +02:00
Vec::new(), &sess);
Hide the quote_*! macros when the feature gate is off This makes it easier to experiment with improved quasiquoting as an ordinary plugin library. The list of quote macros in feature_gate.rs was already out of sync; this commit also prevents that problem in the future.
2014-09-26 17:14:23 -07:00
expand_crate(&sess,test_ecfg(),vec!(),vec!(),crate_ast);
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
}
Rename macro_escape to macro_use In the future we want to support #[macro_use(foo, bar)] mod macros; but it's not an essential part of macro reform. Reserve the syntax for now.
2014-12-18 20:48:26 -08:00
// macro_use modules should allow macros to escape
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
#[test] fn macros_can_escape_flattened_mods_test () {
Rename macro_escape to macro_use In the future we want to support #[macro_use(foo, bar)] mod macros; but it's not an essential part of macro reform. Reserve the syntax for now.
2014-12-18 20:48:26 -08:00
let src = "#[macro_use] mod foo {macro_rules! z (() => (3+4));}\
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
fn inty() -> i32 { z!() }".to_string();
syntax: refactor (Span)Handler and ParseSess constructors to be methods.
2015-05-13 23:00:17 +03:00
let sess = parse::ParseSess::new();
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
let crate_ast = parse::parse_crate_from_source_str(
std: Rename strbuf operations to string [breaking-change]
2014-05-25 03:17:19 -07:00
"<test>".to_string(),
Use @str instead of @~str in libsyntax and librustc. Fixes #5048. This almost removes the StringRef wrapper, since all strings are Equiv-alent now. Removes a lot of `/* bad */ copy *`'s, and converts several things to be &'static str (the lint table and the intrinsics table). There are many instances of .to_managed(), unfortunately.
2013-06-13 03:02:55 +10:00
src,
Fix rustdoc and tests.
2014-03-17 09:55:41 +02:00
Vec::new(), &sess);
Hide the quote_*! macros when the feature gate is off This makes it easier to experiment with improved quasiquoting as an ordinary plugin library. The list of quote macros in feature_gate.rs was already out of sync; this commit also prevents that problem in the future.
2014-09-26 17:14:23 -07:00
expand_crate(&sess, test_ecfg(), vec!(), vec!(), crate_ast);
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
}
core: rename strbuf::StrBuf to string::String [breaking-change]
2014-05-22 16:57:53 -07:00
fn expand_crate_str(crate_str: String) -> ast::Crate {
syntax: refactor (Span)Handler and ParseSess constructors to be methods.
2015-05-13 23:00:17 +03:00
let ps = parse::ParseSess::new();
Work towards a non-panicing parser (libsyntax) - Functions in parser.rs return PResult<> rather than panicing - Other functions in libsyntax call panic! explicitly for now if they rely on panicing behaviour. - 'panictry!' macro added as scaffolding while converting panicing functions. (This does the same as 'unwrap()' but is easier to grep for and turn into try!()) - Leaves panicing wrappers for the following functions so that the quote_* macros behave the same: - parse_expr, parse_item, parse_pat, parse_arm, parse_ty, parse_stmt
2015-03-28 21:58:51 +00:00
let crate_ast = panictry!(string_to_parser(&ps, crate_str).parse_crate_mod());
add hygiene support fns, move them around. also adds test cases
2013-06-25 11:40:51 -07:00
// the cfg argument actually does matter, here...
Hide the quote_*! macros when the feature gate is off This makes it easier to experiment with improved quasiquoting as an ordinary plugin library. The list of quote macros in feature_gate.rs was already out of sync; this commit also prevents that problem in the future.
2014-09-26 17:14:23 -07:00
expand_crate(&ps,test_ecfg(),vec!(),vec!(),crate_ast)
test case support fns, remove debugging test case
2013-07-09 16:00:41 -07:00
}
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
// find the pat_ident paths in a crate
fn crate_bindings(the_crate : &ast::Crate) -> Vec<ast::Ident> {
comments, whitespace, rename NameFinderContext to PatIdentFinder
2014-07-04 12:05:43 -07:00
let mut name_finder = PatIdentFinder{ident_accumulator:Vec::new()};
Remove largely unused context from Visitor.
2014-09-12 13:10:30 +03:00
visit::walk_crate(&mut name_finder, the_crate);
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
name_finder.ident_accumulator
}
add test case for macro token comparison
2013-07-09 15:10:16 -07:00
#[test] fn macro_tokens_should_match(){
libsyntax: Remove uses of `~str` from libsyntax, and fix fallout
2014-05-07 16:33:43 -07:00
expand_crate_str(
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
"macro_rules! m((a)=>(13)) ;fn main(){m!(a);}".to_string());
add test case for macro token comparison
2013-07-09 15:10:16 -07:00
}
macro literals should be compared by name only
2014-07-07 17:43:09 -07:00
// should be able to use a bound identifier as a literal in a macro definition:
#[test] fn self_macro_parsing(){
expand_crate_str(
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
"macro_rules! foo ((zz) => (287;));
fn f(zz: i32) {foo!(zz);}".to_string()
macro literals should be compared by name only
2014-07-07 17:43:09 -07:00
);
}
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// renaming tests expand a crate and then check that the bindings match
// the right varrefs. The specification of the test case includes the
// text of the crate, and also an array of arrays. Each element in the
// outer array corresponds to a binding in the traversal of the AST
// induced by visit. Each of these arrays contains a list of indexes,
// interpreted as the varrefs in the varref traversal that this binding
// should match. So, for instance, in a program with two bindings and
Update old uses of ~ in comments and debugging statements
2015-05-02 16:25:49 -04:00
// three varrefs, the array [[1, 2], [0]] would indicate that the first
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// binding should match the second two varrefs, and the second binding
// should match the first varref.
//
comments only
2014-06-23 18:45:51 -07:00
// Put differently; this is a sparse representation of a boolean matrix
// indicating which bindings capture which identifiers.
//
// Note also that this matrix is dependent on the implicit ordering of
// the bindings and the varrefs discovered by the name-finder and the path-finder.
//
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// The comparisons are done post-mtwt-resolve, so we're comparing renamed
// names; differences in marks don't matter any more.
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
//
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
// oog... I also want tests that check "bound-identifier-=?". That is,
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
// not just "do these have the same name", but "do they have the same
// name *and* the same marks"? Understanding this is really pretty painful.
// in principle, you might want to control this boolean on a per-varref basis,
// but that would make things even harder to understand, and might not be
// necessary for thorough testing.
libsyntax: uint types to usize
2015-01-17 23:33:05 +00:00
type RenamingTest = (&'static str, Vec<Vec<usize>>, bool);
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
add hygiene support fns, move them around. also adds test cases
2013-06-25 11:40:51 -07:00
#[test]
fn automatic_renaming () {
libsyntax: Mechanically change `~[T]` to `Vec<T>`
2014-02-28 13:09:09 -08:00
let tests: Vec<RenamingTest> =
vec!(// b & c should get new names throughout, in the expr too:
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
("fn a() -> i32 { let b = 13; let c = b; b+c }",
libsyntax: Mechanically change `~[T]` to `Vec<T>`
2014-02-28 13:09:09 -08:00
vec!(vec!(0,1),vec!(2)), false),
test case work
2013-06-07 15:01:28 -07:00
// both x's should be renamed (how is this causing a bug?)
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
("fn main () {let x: i32 = 13;x;}",
libsyntax: Mechanically change `~[T]` to `Vec<T>`
2014-02-28 13:09:09 -08:00
vec!(vec!(0)), false),
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// the use of b after the + should be renamed, the other one not:
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
("macro_rules! f (($x:ident) => (b + $x)); fn a() -> i32 { let b = 13; f!(b)}",
libsyntax: Mechanically change `~[T]` to `Vec<T>`
2014-02-28 13:09:09 -08:00
vec!(vec!(1)), false),
renaming test cases
2013-06-06 11:21:02 -07:00
// the b before the plus should not be renamed (requires marks)
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
("macro_rules! f (($x:ident) => ({let b=9; ($x + b)})); fn a() -> i32 { f!(b)}",
libsyntax: Mechanically change `~[T]` to `Vec<T>`
2014-02-28 13:09:09 -08:00
vec!(vec!(1)), false),
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// the marks going in and out of letty should cancel, allowing that $x to
// capture the one following the semicolon.
// this was an awesome test case, and caught a *lot* of bugs.
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
("macro_rules! letty(($x:ident) => (let $x = 15;));
macro_rules! user(($x:ident) => ({letty!($x); $x}));
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
fn main() -> i32 {user!(z)}",
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
vec!(vec!(0)), false)
);
added index to test cases, more debugging output
2013-09-05 13:28:57 -07:00
for (idx,s) in tests.iter().enumerate() {
run_renaming_test(s,idx);
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
}
}
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
// no longer a fixme #8062: this test exposes a *potential* bug; our system does
// not behave exactly like MTWT, but a conversation with Matthew Flatt
// suggests that this can only occur in the presence of local-expand, which
// we have no plans to support. ... unless it's needed for item hygiene....
#[ignore]
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn issue_8062(){
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
run_renaming_test(
&("fn main() {let hrcoo = 19; macro_rules! getx(()=>(hrcoo)); getx!();}",
vec!(vec!(0)), true), 0)
}
// FIXME #6994:
// the z flows into and out of two macros (g & f) along one path, and one
// (just g) along the other, so the result of the whole thing should
// be "let z_123 = 3; z_123"
#[ignore]
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn issue_6994(){
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
run_renaming_test(
&("macro_rules! g (($x:ident) =>
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
({macro_rules! f(($y:ident)=>({let $y=3;$x}));f!($x)}));
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
fn a(){g!(z)}",
vec!(vec!(0)),false),
0)
add unit test for match var hygiene
2014-06-24 16:34:03 -07:00
}
adjust fold to fold over interpolated items/exprs/etc. Closes #15221
2014-06-27 16:10:23 -07:00
// match variable hygiene. Should expand into
improve match test case to include guard
2014-06-26 15:37:45 -07:00
// fn z() {match 8 {x_1 => {match 9 {x_2 | x_2 if x_2 == x_1 => x_2 + x_1}}}}
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn issue_9384(){
add unit test for match var hygiene
2014-06-24 16:34:03 -07:00
run_renaming_test(
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
&("macro_rules! bad_macro (($ex:expr) => ({match 9 {x | x if x == $ex => x + $ex}}));
improve match test case to include guard
2014-06-26 15:37:45 -07:00
fn z() {match 8 {x => bad_macro!(x)}}",
add unit test for match var hygiene
2014-06-24 16:34:03 -07:00
// NB: the third "binding" is the repeat of the second one.
improve match test case to include guard
2014-06-26 15:37:45 -07:00
vec!(vec!(1,3),vec!(0,2),vec!(0,2)),
add unit test for match var hygiene
2014-06-24 16:34:03 -07:00
true),
0)
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
}
adjust fold to fold over interpolated items/exprs/etc. Closes #15221
2014-06-27 16:10:23 -07:00
// interpolated nodes weren't getting labeled.
added unit and standalone test for 15221, extra debugging output
2014-06-27 13:10:47 -07:00
// should expand into
// fn main(){let g1_1 = 13; g1_1}}
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn pat_expand_issue_15221(){
added unit and standalone test for 15221, extra debugging output
2014-06-27 13:10:47 -07:00
run_renaming_test(
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
&("macro_rules! inner ( ($e:pat ) => ($e));
macro_rules! outer ( ($e:pat ) => (inner!($e)));
added unit and standalone test for 15221, extra debugging output
2014-06-27 13:10:47 -07:00
fn main() { let outer!(g) = 13; g;}",
vec!(vec!(0)),
true),
0)
}
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
// create a really evil test case where a $x appears inside a binding of $x
Fix spelling errors.
2014-07-02 21:27:07 -04:00
// but *shouldn't* bind because it was inserted by a different macro....
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
// can't write this test case until we have macro-generating macros.
added test for method arg hygiene
2014-07-04 10:57:17 -07:00
// method arg hygiene
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
// method expands to fn get_x(&self_0, x_1: i32) {self_0 + self_2 + x_3 + x_1}
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn method_arg_hygiene(){
added test for method arg hygiene
2014-07-04 10:57:17 -07:00
run_renaming_test(
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
&("macro_rules! inject_x (()=>(x));
macro_rules! inject_self (()=>(self));
added test for method arg hygiene
2014-07-04 10:57:17 -07:00
struct A;
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
impl A{fn get_x(&self, x: i32) {self + inject_self!() + inject_x!() + x;} }",
added test for method arg hygiene
2014-07-04 10:57:17 -07:00
vec!(vec!(0),vec!(3)),
true),
0)
}
self arg macro test case
2014-07-07 09:53:41 -07:00
// ooh, got another bite?
// expands to struct A; impl A {fn thingy(&self_1) {self_1;}}
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn method_arg_hygiene_2(){
self arg macro test case
2014-07-07 09:53:41 -07:00
run_renaming_test(
&("struct A;
macro_rules! add_method (($T:ty) =>
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
(impl $T { fn thingy(&self) {self;} }));
add_method!(A);",
self arg macro test case
2014-07-07 09:53:41 -07:00
vec!(vec!(0)),
true),
0)
}
comments only
2014-07-04 10:57:28 -07:00
// item fn hygiene
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
// expands to fn q(x_1: i32){fn g(x_2: i32){x_2 + x_1};}
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn issue_9383(){
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
run_renaming_test(
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
&("macro_rules! bad_macro (($ex:expr) => (fn g(x: i32){ x + $ex }));
fn q(x: i32) { bad_macro!(x); }",
simplify and uncomment item-fn-arg hygiene unit test
2014-06-30 12:42:33 -07:00
vec!(vec!(1),vec!(0)),true),
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
0)
simplify and uncomment item-fn-arg hygiene unit test
2014-06-30 12:42:33 -07:00
}
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
Merge the ExprFnBlock and ExprUnboxedClosure into one ExprClosure with an optional unboxed closure kind.
2014-11-19 11:18:17 -05:00
// closure arg hygiene (ExprClosure)
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
// expands to fn f(){(|x_1 : i32| {(x_2 + x_1)})(3);}
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn closure_arg_hygiene(){
added test cases for closure arg hygiene
2014-07-04 11:02:17 -07:00
run_renaming_test(
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
&("macro_rules! inject_x (()=>(x));
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
fn f(){(|x : i32| {(inject_x!() + x)})(3);}",
added test cases for closure arg hygiene
2014-07-04 11:02:17 -07:00
vec!(vec!(1)),
true),
0)
}
carry self ident forward through re-parsing formerly, the self identifier was being discarded during parsing, which stymies hygiene. The best fix here seems to be to attach a self identifier to ExplicitSelf_, a change that rippled through the rest of the compiler, but without any obvious damage.
2014-07-06 15:10:57 -07:00
// macro_rules in method position. Sadly, unimplemented.
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn macro_in_method_posn(){
test case for expansion of method macro
2014-07-07 15:12:31 -07:00
expand_crate_str(
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
"macro_rules! my_method (() => (fn thirteen(&self) -> i32 {13}));
test case for expansion of method macro
2014-07-07 15:12:31 -07:00
struct A;
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
impl A{ my_method!(); }
test case for expansion of method macro
2014-07-07 15:12:31 -07:00
fn f(){A.thirteen;}".to_string());
}
carry self ident forward through re-parsing formerly, the self identifier was being discarded during parsing, which stymies hygiene. The best fix here seems to be to attach a self identifier to ExplicitSelf_, a change that rippled through the rest of the compiler, but without any obvious damage.
2014-07-06 15:10:57 -07:00
// another nested macro
// expands to impl Entries {fn size_hint(&self_1) {self_1;}
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn item_macro_workaround(){
carry self ident forward through re-parsing formerly, the self identifier was being discarded during parsing, which stymies hygiene. The best fix here seems to be to attach a self identifier to ExplicitSelf_, a change that rippled through the rest of the compiler, but without any obvious damage.
2014-07-06 15:10:57 -07:00
run_renaming_test(
&("macro_rules! item { ($i:item) => {$i}}
struct Entries;
macro_rules! iterator_impl {
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
() => { item!( impl Entries { fn size_hint(&self) { self;}});}}
carry self ident forward through re-parsing formerly, the self identifier was being discarded during parsing, which stymies hygiene. The best fix here seems to be to attach a self identifier to ExplicitSelf_, a change that rippled through the rest of the compiler, but without any obvious damage.
2014-07-06 15:10:57 -07:00
iterator_impl! { }",
vec!(vec!(0)), true),
0)
}
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
// run one of the renaming tests
libsyntax: uint types to usize
2015-01-17 23:33:05 +00:00
fn run_renaming_test(t: &RenamingTest, test_idx: usize) {
add test case, cleanup
2013-09-05 09:29:31 -07:00
let invalid_name = token::special_idents::invalid.name;
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
let (teststr, bound_connections, bound_ident_check) = match *t {
Rename functions in the CloneableVector trait * Deprecated `to_owned` in favor of `to_vec` * Deprecated `into_owned` in favor of `into_vec` [breaking-change]
2014-07-16 22:37:28 +02:00
(ref str,ref conns, bic) => (str.to_string(), conns.clone(), bic)
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
};
std: Rename strbuf operations to string [breaking-change]
2014-05-25 03:17:19 -07:00
let cr = expand_crate_str(teststr.to_string());
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
let bindings = crate_bindings(&cr);
let varrefs = crate_varrefs(&cr);
syntax: remove dead @mut Visitor impl (only used in tests). Also, move some code only uses in the tests into the test module, and replace some needless @mut ~[] with plain ~[].
2013-10-28 19:20:26 +11:00
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// must be one check clause for each binding:
assert_eq!(bindings.len(),bound_connections.len());
for (binding_idx,shouldmatch) in bound_connections.iter().enumerate() {
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
let binding_name = mtwt::resolve(bindings[binding_idx]);
let binding_marks = mtwt::marksof(bindings[binding_idx].ctxt, invalid_name);
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// shouldmatch can't name varrefs that don't exist:
Positive case of `len()` -> `is_empty()` `s/(?<!\{ self)(?<=\.)len\(\) == 0/is_empty()/g`
2015-03-24 16:53:34 -07:00
assert!((shouldmatch.is_empty()) ||
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
(varrefs.len() > *shouldmatch.iter().max().unwrap()));
for (idx,varref) in varrefs.iter().enumerate() {
remove all kind annotations from closures
2015-02-01 12:44:15 -05:00
let print_hygiene_debug_info = || {
test harness cleanup
2014-07-06 15:06:32 -07:00
// good lord, you can't make a path with 0 segments, can you?
let final_varref_ident = match varref.segments.last() {
Some(pathsegment) => pathsegment.identifier,
Rename fail! to panic! https://github.com/rust-lang/rfcs/pull/221 The current terminology of "task failure" often causes problems when writing or speaking about code. You often want to talk about the possibility of an operation that returns a Result "failing", but cannot because of the ambiguity with task failure. Instead, you have to speak of "the failing case" or "when the operation does not succeed" or other circumlocutions. Likewise, we use a "Failure" header in rustdoc to describe when operations may fail the task, but it would often be helpful to separate out a section describing the "Err-producing" case. We have been steadily moving away from task failure and toward Result as an error-handling mechanism, so we should optimize our terminology accordingly: Result-producing functions should be easy to describe. To update your code, rename any call to `fail!` to `panic!` instead. Assuming you have not created your own macro named `panic!`, this will work on UNIX based systems: grep -lZR 'fail!' . | xargs -0 -l sed -i -e 's/fail!/panic!/g' You can of course also do this by hand. [breaking-change]
2014-10-09 15:17:22 -04:00
None => panic!("varref with 0 path segments?")
test harness cleanup
2014-07-06 15:06:32 -07:00
};
let varref_name = mtwt::resolve(final_varref_ident);
let varref_idents : Vec<ast::Ident>
= varref.segments.iter().map(|s| s.identifier)
.collect();
Test fixes and rebase conflicts
2015-01-07 18:53:58 -08:00
println!("varref #{}: {:?}, resolves to {}",idx, varref_idents, varref_name);
test harness cleanup
2014-07-06 15:06:32 -07:00
let string = token::get_ident(final_varref_ident);
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
println!("varref's first segment's string: \"{}\"", &string[..]);
test harness cleanup
2014-07-06 15:06:32 -07:00
println!("binding #{}: {}, resolves to {}",
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
binding_idx, bindings[binding_idx], binding_name);
test harness cleanup
2014-07-06 15:06:32 -07:00
mtwt::with_sctable(|x| mtwt::display_sctable(x));
};
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
if shouldmatch.contains(&idx) {
// it should be a path of length 1, and it should
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
// be free-identifier=? or bound-identifier=? to the given binding
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
assert_eq!(varref.segments.len(),1);
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
let varref_name = mtwt::resolve(varref.segments[0].identifier);
let varref_marks = mtwt::marksof(varref.segments[0]
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
.identifier
.ctxt,
invalid_name);
syntax: Remove usage of io_error in tests
2014-01-30 14:28:44 -08:00
if !(varref_name==binding_name) {
Remove re-exports of std::io::stdio::{print, println} in the prelude. The `print!` and `println!` macros are now the preferred method of printing, and so there is no reason to export the `stdio` functions in the prelude. The functions have also been replaced by their macro counterparts in the tutorial and other documentation so that newcomers don't get confused about what they should be using.
2014-01-09 21:06:55 +11:00
println!("uh oh, should match but doesn't:");
test harness cleanup
2014-07-06 15:06:32 -07:00
print_hygiene_debug_info();
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
}
assert_eq!(varref_name,binding_name);
syntax: Remove usage of io_error in tests
2014-01-30 14:28:44 -08:00
if bound_ident_check {
add test case, cleanup
2013-09-05 09:29:31 -07:00
// we're checking bound-identifier=?, and the marks
// should be the same, too:
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
assert_eq!(varref_marks,binding_marks.clone());
}
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
} else {
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
let varref_name = mtwt::resolve(varref.segments[0].identifier);
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
let fail = (varref.segments.len() == 1)
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
&& (varref_name == binding_name);
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
// temp debugging:
syntax: Remove usage of io_error in tests
2014-01-30 14:28:44 -08:00
if fail {
added index to test cases, more debugging output
2013-09-05 13:28:57 -07:00
println!("failure on test {}",test_idx);
println!("text of test case: \"{}\"", teststr);
println!("");
println!("uh oh, matches but shouldn't:");
test harness cleanup
2014-07-06 15:06:32 -07:00
print_hygiene_debug_info();
marking on both input and output from macros. nice shiny new test case framework
2013-06-29 05:59:08 -07:00
}
assert!(!fail);
}
}
add hygiene support fns, move them around. also adds test cases
2013-06-25 11:40:51 -07:00
}
}
moved TLS of sctable to ast_util, hid parameter in hygiene calls
2013-05-21 16:57:21 -07:00
cleanup: Test formatting
2015-03-28 20:16:11 -07:00
#[test]
fn fmt_in_macro_used_inside_module_macro() {
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 09:18:10 -08:00
let crate_str = "macro_rules! fmt_wrap(($b:expr)=>($b.to_string()));
macro_rules! foo_module (() => (mod generated { fn a() { let xx = 147; fmt_wrap!(xx);}}));
foo_module!();
std: Rename strbuf operations to string [breaking-change]
2014-05-25 03:17:19 -07:00
".to_string();
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
let cr = expand_crate_str(crate_str);
// find the xx binding
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
let bindings = crate_bindings(&cr);
libsyntax: Mechanically change `~[T]` to `Vec<T>`
2014-02-28 13:09:09 -08:00
let cxbinds: Vec<&ast::Ident> =
librustc: Remove unique vector patterns from the language. Preparatory work for removing unique vectors from the language, which is itself preparatory work for dynamically sized types.
2014-02-13 09:46:46 -08:00
bindings.iter().filter(|b| {
let ident = token::get_ident(**b);
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
let string = &ident[..];
librustc: Remove unique vector patterns from the language. Preparatory work for removing unique vectors from the language, which is itself preparatory work for dynamically sized types.
2014-02-13 09:46:46 -08:00
"xx" == string
}).collect();
Replace all uses of `&foo[]` with `&foo[..]` en masse.
2015-02-18 14:48:57 -05:00
let cxbinds: &[&ast::Ident] = &cxbinds[..];
syntax: Remove uses of #[feature(slice_patterns)]
2015-04-15 22:12:12 -07:00
let cxbind = match (cxbinds.len(), cxbinds.get(0)) {
(1, Some(b)) => *b,
Rename fail! to panic! https://github.com/rust-lang/rfcs/pull/221 The current terminology of "task failure" often causes problems when writing or speaking about code. You often want to talk about the possibility of an operation that returns a Result "failing", but cannot because of the ambiguity with task failure. Instead, you have to speak of "the failing case" or "when the operation does not succeed" or other circumlocutions. Likewise, we use a "Failure" header in rustdoc to describe when operations may fail the task, but it would often be helpful to separate out a section describing the "Err-producing" case. We have been steadily moving away from task failure and toward Result as an error-handling mechanism, so we should optimize our terminology accordingly: Result-producing functions should be easy to describe. To update your code, rename any call to `fail!` to `panic!` instead. Assuming you have not created your own macro named `panic!`, this will work on UNIX based systems: grep -lZR 'fail!' . | xargs -0 -l sed -i -e 's/fail!/panic!/g' You can of course also do this by hand. [breaking-change]
2014-10-09 15:17:22 -04:00
_ => panic!("expected just one binding for ext_cx")
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
};
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
let resolved_binding = mtwt::resolve(*cxbind);
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
let varrefs = crate_varrefs(&cr);
syntax: remove dead @mut Visitor impl (only used in tests). Also, move some code only uses in the tests into the test module, and replace some needless @mut ~[] with plain ~[].
2013-10-28 19:20:26 +11:00
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
// the xx binding should bind all of the xx varrefs:
Refactored ast_map and friends, mainly to have Paths without storing them.
2014-02-14 07:07:09 +02:00
for (idx,v) in varrefs.iter().filter(|p| {
libsyntax: Remove many uses of `token::ident_to_str`
2014-01-31 15:26:59 -08:00
p.segments.len() == 1
Fix errors from #22592
2015-02-21 16:26:57 +05:30
&& "xx" == &*token::get_ident(p.segments[0].identifier)
libsyntax: Remove many uses of `token::ident_to_str`
2014-01-31 15:26:59 -08:00
}).enumerate() {
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
if mtwt::resolve(v.segments[0].identifier) != resolved_binding {
Remove re-exports of std::io::stdio::{print, println} in the prelude. The `print!` and `println!` macros are now the preferred method of printing, and so there is no reason to export the `stdio` functions in the prelude. The functions have also been replaced by their macro counterparts in the tutorial and other documentation so that newcomers don't get confused about what they should be using.
2014-01-09 21:06:55 +11:00
println!("uh oh, xx binding didn't match xx varref:");
libsyntax: Remove all uses of {:?}.
2014-10-14 21:59:41 -04:00
println!("this is xx varref \\# {}", idx);
println!("binding: {}", cxbind);
println!("resolves to: {}", resolved_binding);
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
println!("varref: {}", v.segments[0].identifier);
libsyntax: Remove all uses of {:?}.
2014-10-14 21:59:41 -04:00
println!("resolves to: {}",
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
mtwt::resolve(v.segments[0].identifier));
Refactor and fix FIXME's in mtwt hygiene code - Moves mtwt hygiene code into its own file - Fixes FIXME's which leads to ~2x speed gain in expansion pass - It is now @-free
2014-02-25 04:47:19 +08:00
mtwt::with_sctable(|x| mtwt::display_sctable(x));
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
}
Remove a large amount of deprecated functionality Spring cleaning is here! In the Fall! This commit removes quite a large amount of deprecated functionality from the standard libraries. I tried to ensure that only old deprecated functionality was removed. This is removing lots and lots of deprecated features, so this is a breaking change. Please consult the deprecation messages of the deleted code to see how to migrate code forward if it still needs migration. [breaking-change]
2014-10-14 23:05:01 -07:00
assert_eq!(mtwt::resolve(v.segments[0].identifier),
libsyntax: Fix errors arising from the automated `~[T]` conversion
2014-02-28 12:54:01 -08:00
resolved_binding);
awesome new bug! added test case
2013-07-12 18:35:47 -07:00
};
}
add hygiene support functions
2013-06-04 14:56:33 -07:00
#[test]
fn pat_idents(){
libsyntax: Remove uses of `~str` from libsyntax, and fix fallout
2014-05-07 16:33:43 -07:00
let pat = string_to_pat(
std: Rename strbuf operations to string [breaking-change]
2014-05-25 03:17:19 -07:00
"(a,Foo{x:c @ (b,9),y:Bar(4,d)})".to_string());
librustc: Remove cross-borrowing of `Box<T>` to `&T` from the language, except where trait objects are involved. Part of issue #15349, though I'm leaving it open for trait objects. Cross borrowing for trait objects remains because it is needed until we have DST. This will break code like: fn foo(x: &int) { ... } let a = box 3i; foo(a); Change this code to: fn foo(x: &int) { ... } let a = box 3i; foo(&*a); [breaking-change]
2014-07-07 16:35:15 -07:00
let idents = pattern_bindings(&*pat);
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
assert_eq!(idents, strs_to_idents(vec!("a","c","b","d")));
add hygiene support functions
2013-06-04 14:56:33 -07:00
}
test case work
2013-06-07 12:28:03 -07:00
enrich and rename crate_idents test case
2014-06-24 16:33:44 -07:00
// test the list of identifier patterns gathered by the visitor. Note that
// 'None' is listed as an identifier pattern because we don't yet know that
// it's the name of a 0-ary variant, and that 'i' appears twice in succession.
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
#[test]
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
fn crate_bindings_test(){
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
let the_crate = string_to_crate("fn main (a: i32) -> i32 {|b| {
enrich and rename crate_idents test case
2014-06-24 16:33:44 -07:00
match 34 {None => 3, Some(i) | i => j, Foo{k:z,l:y} => \"banana\"}} }".to_string());
cleanup and shiny new more-functional interface
2014-06-26 14:39:54 -07:00
let idents = crate_bindings(&the_crate);
assert_eq!(idents, strs_to_idents(vec!("a","b","None","i","i","z","y")));
revive old commented-out test cases as ignored test cases for hygiene
2013-11-11 17:35:25 -08:00
}
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
// test the IdentRenamer directly
#[test]
fn ident_renamer_test () {
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
let the_crate = string_to_crate("fn f(x: i32){let x = x; x}".to_string());
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
let f_ident = token::str_to_ident("f");
let x_ident = token::str_to_ident("x");
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
let int_ident = token::str_to_ident("i32");
Fix all the test fallout
2014-07-08 22:28:52 -07:00
let renames = vec!((x_ident,Name(16)));
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
let mut renamer = IdentRenamer{renames: &renames};
let renamed_crate = renamer.fold_crate(the_crate);
let idents = crate_idents(&renamed_crate);
let resolved : Vec<ast::Name> = idents.iter().map(|id| mtwt::resolve(*id)).collect();
Use arrays instead of vectors in tests
2015-02-24 21:15:45 +03:00
assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),Name(16),Name(16)]);
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
}
// test the PatIdentRenamer; only PatIdents get renamed
#[test]
fn pat_ident_renamer_test () {
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
let the_crate = string_to_crate("fn f(x: i32){let x = x; x}".to_string());
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
let f_ident = token::str_to_ident("f");
let x_ident = token::str_to_ident("x");
libsyntax: int => i32 in appropriate places
2015-01-17 23:55:21 +00:00
let int_ident = token::str_to_ident("i32");
Fix all the test fallout
2014-07-08 22:28:52 -07:00
let renames = vec!((x_ident,Name(16)));
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
let mut renamer = PatIdentRenamer{renames: &renames};
let renamed_crate = renamer.fold_crate(the_crate);
let idents = crate_idents(&renamed_crate);
let resolved : Vec<ast::Name> = idents.iter().map(|id| mtwt::resolve(*id)).collect();
let x_name = x_ident.name;
Use arrays instead of vectors in tests
2015-02-24 21:15:45 +03:00
assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),x_name,x_name]);
comments & test cases for IdentRenamers
2014-07-04 12:18:37 -07:00
}
Macros now leave scope Macro scope is now delimited by function, block, and module boundaries, except for modules that are marked with #[macro_escape], which allows macros to escape.
2013-02-26 10:15:29 -08:00
}
Reference in a new issue Copy permalink