dead_code false positive on matched enum

[durka]

This code produces a dead code warning for the entire enum, but it isn't dead because the match expression refers to it. Or do I have the wrong definition of "dead"? (I generally assume when rustc says "this is dead" it means "you can comment this out".)

enum Color {
    Brown,
    Green,
}

fn main() {
    let x = None;
    match x {
        Some(t) => match t {
            Color::Brown => println!("it's brown"),
            Color::Green => println!("it's green"),
        },
        None => println!("nothing"),
    }
}

[sanxiyn]

Warning is intentional, as value of enum is never constructed and match arms can't be reached. It actually is the case that "you can comment this out".

[durka]

If you comment out the enum, you have to comment out the match as well, otherwise it doesn't compile. So it doesn't seem very dead, to me.

[sanxiyn]

See also #27559.

[arielb1]

@durka

It is this way intentionally, exactly to catch variants that are not created anywhere.

[durka]

Ok, thanks for the explanation! At first I thought "but what if someone else instantiates one?" but if you make it pub the misleading message goes away, so it's unlikely to affect real code.

[apoelstra]

Here is real code this affects. It's part of a macro-ization of the manual implementation of serde::Serialize. Grep for impl<'a> serde::ser::MapVisitor for PointMapVisitor<'a> to find the relevant code, which uses an integer to act as a state machine. In macros you cannot get a list of consecutive numbers like this, so I used an enum as:

            #[repr(u16)]
            #[derive(Copy, Clone)]
            #[allow(non_camel_case_types)]
            pub enum State { $($fe),* , Finished }

            pub struct MapVisitor<'a> {
                pub value: &'a super::$name,
                pub state: State,
            }

            impl<'a> ::serde::ser::MapVisitor for MapVisitor<'a> {
                fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
                    where S: ::serde::Serializer
                {
                    match self.state {
                        $(State::$fe => {
                            self.state = unsafe { ::std::mem::transmute(self.state as u16 + 1) };
                            Ok(Some(try!(serializer.visit_struct_elt(stringify!($fe), &self.value.$fe))))
                        })*
                        State::Finished => {
                            Ok(None)
                        }
                    }
                }
            }
        }

Later the enum is instantiated with a transmutation of 0.

The error still occurs, even though every single enum variant actually gets used.

[arielb1]

Later the enum is instantiated with a transmutation of 0.

That's your problem. Just use allow(dead_code).