rust/tests/ui/proc-macro/modify-ast.rs

//@ run-pass
//@ proc-macro: modify-ast.rs
//@ ignore-backends: gcc

extern crate modify_ast;

use modify_ast::*;

#[derive(Foo)]
pub struct MyStructc {
    #[cfg_attr(FALSE, foo)]
    _a: i32,
}

macro_rules! a {
    ($i:item) => ($i)
}

a! {
    #[assert1]
    pub fn foo() {}
}

fn main() {
    let _a = MyStructc { _a: 0 };
    foo();
}
tests: Add missing run-pass annotations 2019-07-27 00:54:25 +03:00			`//@ run-pass`
Update tests to use new proc-macro header 2024-11-24 17:37:25 -08:00			`//@ proc-macro: modify-ast.rs`
Ignore more failing ui tests for GCC backend 2025-09-26 13:59:06 +02:00			`//@ ignore-backends: gcc`
proc_macro: Avoid cached TokenStream more often This commit adds even more pessimization to use the cached `TokenStream` inside of an AST node. As a reminder the `proc_macro` API requires taking an arbitrary AST node and transforming it back into a `TokenStream` to hand off to a procedural macro. Such functionality isn't actually implemented in rustc today, so the way `proc_macro` works today is that it stringifies an AST node and then reparses for a list of tokens. This strategy unfortunately loses all span information, so we try to avoid it whenever possible. Implemented in #43230 some AST nodes have a `TokenStream` cache representing the tokens they were originally parsed from. This `TokenStream` cache, however, has turned out to not always reflect the current state of the item when it's being tokenized. For example `#[cfg]` processing or macro expansion could modify the state of an item. Consequently we've seen a number of bugs (#48644 and #49846) related to using this stale cache. This commit tweaks the usage of the cached `TokenStream` to compare it to our lossy stringification of the token stream. If the tokens that make up the cache and the stringified token stream are the same then we return the cached version (which has correct span information). If they differ, however, then we will return the stringified version as the cache has been invalidated and we just haven't figured that out. Closes #48644 Closes #49846 2018-04-10 12:52:47 -07:00
			`extern crate modify_ast;`

			`use modify_ast::*;`

			`#[derive(Foo)]`
			`pub struct MyStructc {`
Unify all the always-false cfgs under the `FALSE` cfg 2024-04-07 00:43:00 +02:00			`#[cfg_attr(FALSE, foo)]`
proc_macro: Avoid cached TokenStream more often This commit adds even more pessimization to use the cached `TokenStream` inside of an AST node. As a reminder the `proc_macro` API requires taking an arbitrary AST node and transforming it back into a `TokenStream` to hand off to a procedural macro. Such functionality isn't actually implemented in rustc today, so the way `proc_macro` works today is that it stringifies an AST node and then reparses for a list of tokens. This strategy unfortunately loses all span information, so we try to avoid it whenever possible. Implemented in #43230 some AST nodes have a `TokenStream` cache representing the tokens they were originally parsed from. This `TokenStream` cache, however, has turned out to not always reflect the current state of the item when it's being tokenized. For example `#[cfg]` processing or macro expansion could modify the state of an item. Consequently we've seen a number of bugs (#48644 and #49846) related to using this stale cache. This commit tweaks the usage of the cached `TokenStream` to compare it to our lossy stringification of the token stream. If the tokens that make up the cache and the stringified token stream are the same then we return the cached version (which has correct span information). If they differ, however, then we will return the stringified version as the cache has been invalidated and we just haven't figured that out. Closes #48644 Closes #49846 2018-04-10 12:52:47 -07:00			`_a: i32,`
			`}`

			`macro_rules! a {`
			`($i:item) => ($i)`
			`}`

			`a! {`
			`#[assert1]`
			`pub fn foo() {}`
			`}`

			`fn main() {`
			`let _a = MyStructc { _a: 0 };`
			`foo();`
			`}`