Invalid derive proc macro output silently ignored

[m-ou-se]

A derive proc macro expanding to something starting with a { is ignored:

use proc_macro::TokenStream;

#[proc_macro_derive(Test)]
pub fn test(_: TokenStream) -> TokenStream {
    quote::quote!(
        {}
        fn main() {}
    ).into()
}

use scratchpad::Test;

#[derive(Test)]
struct A;

error[E0601]: `main` function not found in crate `scratchpad`
 --> src/main.rs:1:1
  |
1 | / use scratchpad::Test;
2 | |
3 | | #[derive(Test)]
4 | | struct A;
  | |_________^ consider adding a `main` function to `src/main.rs`

[m-ou-se]

Another example:

This compiles fine, but should fail:

use proc_macro::TokenStream;

#[proc_macro_derive(Test)]
pub fn test(_: TokenStream) -> TokenStream {
    "{} ! @ # $ blåhaj % ^ &".parse().unwrap()
}

use scratchpad::Test;

#[derive(Test)]
struct A;

fn main() {}

[Aaron1011]

This is caused by the proc-macro expansion code failing to check if there are any remaining tokens in the input:

rust/compiler/rustc_expand/src/proc_macro.rs

Lines 119 to 134 in 5c0ca08

	loop {
	match parser.parse_item(ForceCollect::No) {
	Ok(None) => break,
	Ok(Some(item)) => {
	if is_stmt {
	items.push(Annotatable::Stmt(P(ecx.stmt_item(span, item))));
	} else {
	items.push(Annotatable::Item(item));
	}
	}
	Err(mut err) => {
	err.emit();
	break;
	}
	}
	}

I'm working on a fix

[jonas-schievink]

@Aaron1011 #87316 already fixes this

[petrochenkov]

IIRC, this is a duplicate of some old issue.
Things were working like this since the original implementation of custom derives, so the fix will likely require a crater run.

[m-ou-se]

Yeah let's see if anything breaks. The alternative is to make it a (future_incompatible) lint instead.

[domenicquirl]

I ran into this over the past few days trying to add a new derive macro to a crate I maintain. A superfluous semicolon snuck its way into the output of the derive, causing any subsequent code to be silently dropped (from what I can tell from this comment, semicolons seem to be a more common cause for this issue).

My code produced an enum and an impl Trait for that enum. The following proc macro code will only emit the enum declaration and will not implement Display for Foo:

use ::proc_macro::*;

#[proc_macro_derive(Foo)] pub
fn __(_input: TokenStream)
  -> TokenStream
{
    stringify!(
        enum Foo {};

        impl ::core::fmt::Display for Foo {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                f.write_str("Foo")
            }
        }
    )
    .parse()
    .unwrap()
}

(independently of the method of constructing the TokenStream, the same happens if you quote! the code)

This confused me for a good while, because initially I wrote multiple tests for the proc macro with function-local enums deriving Foo:

#[test]  
fn foo() {
    #[derive(Foo)]
    enum Bar {}
}

The emitted code is valid inside method bodies (playground), which is the scope that the derive output is emitted to, so it took the help of @danielhenrymantilla to figure out the last piece after it became clear that the ; was at fault.

I would expect the compiler to produce at least a warning, especially given that the macro output compiles if you write the same code by hand (when invoked inside a fn).