declare_interior_mutable_const and borrow_interior_mutable_const need to respect enum variants

[devsnek]

#[derive(Debug)]
enum Thing {
	// variant A has interior mutability
    A(std::cell::Cell<bool>),
	// variant B clearly does not
    B,
}

impl Thing {
    // declare_interior_mutable_const triggers here
    pub const BB: Thing = Thing::B;
}

fn main() {
    // borrow_interior_mutable_const triggers here
    println!("Thing::BB = {:?}", Thing::BB);
}

I realize that it isn't possible to know if the thing on the rhs of a const declaration is interior mutable or not without full const evaluation, but trivial cases such as the example shouldn't be too difficult.

[ijackson]

I just tripped over this. In my case, it occurs with a trait constant:

use std::io;
use std::error::Error;
use thiserror::Error;

#[derive(Debug,Error)]
#[error("my error {:?}",self)]
pub enum MyError {
    Simple,
    Complicated(io::Error), // <- so MyError cannot be Copy
}

pub trait Trait {
    type Error : Error;
    #[allow(clippy::declare_interior_mutable_const)]
    const ERROR : Self::Error;
}

pub struct Object;

impl Trait for Object {
    type Error = MyError;
    const ERROR : MyError = MyError::Simple;
}

The playground doesn't have thiserror, so here is my Cargo.toml:

[package]
name="junk"
version="0.0.0"
edition="2018"
[dependencies]
thiserror="1"

[ijackson]

It's probably also possible to get a false positive from this without using an enum, if there is some other kind of type that can be constructed const but which is not Copy.

I think the the root of this particular problem is that the lint ought to depend on the value of the constant, rather than the type.

[rail-rain]

@ijackson I think what you found is actually something related to #5050 because I believe the below is the only error message you'd get if you removed #[allow(...)] from the example; and it says the type of the constant ERROR - Self::Error associated type - is not guaranteed to be interior mutability free; therefore it has nothing to do with the MyError enum and the Object struct. Is that right?

error: a `const` item should never be interior mutable
  --> src/main.rs:15:5
   |
15 |     const ERROR : Self::Error;
   |     ^^^^^^^^^^^^^^-----------^
   |                   |
   |                   consider requiring `<Self as Trait>::Error` to be `Copy`
   |
   = note: `#[deny(clippy::declare_interior_mutable_const)]` on by default
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#declare_interior_mutable_const

The minimum example on the playground