Duplicate definition of type for rustc::mir::Constant

[bjorn3]

rustc::mir::Constant has a field ty, but its field literal contains a Const which itself already contains a Ty.

[oli-obk]

These types aren't always equal. e.g. the lifetimes often differ, and I think around impl trait some inconsistencies can happen, too. we should probably document this much better and/or figure out whether we need the duplication

[eddyb]

Looks like #61041 is blocked on fixing this.

EDIT: to expand on that, this example:

trait Zero {
    type Repr;
    const ZERO: Self::Repr;
}

impl Zero for char {
    type Repr = u32;
    const ZERO: u32 = 0;
}

const ONE: u32 = char::ZERO + 1;

Has this for the char::ZERO in the MIR of ONE:

// mir::Constant
// + span: src/lib.rs:11:18: 11:28
// + ty: u32
// + literal: Const { ty: <Self as Zero>::Repr, val: Unevaluated(DefId(0:14 ~ playground[5f8c]::Zero[0]::ZERO[0]), [char]) }

Note the <Self as Zero>::Repr in literal.ty, which is clearly wrong for ONE (appears to be unsubstituted), while ty is correct.

[RalfJung]

This is interesting, maybe:

impl<'tcx> TypeFoldable<'tcx> for Constant<'tcx> {
    fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
        Constant {
            span: self.span.clone(),
            ty: self.ty.fold_with(folder),
            user_ty: self.user_ty.fold_with(folder),
            literal: self.literal.fold_with(folder),
        }
    }
    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
        self.ty.visit_with(visitor) || self.literal.visit_with(visitor)
    }
}

Notice how super_visit_with skips user_ty, but super_fold_with does not. OTOH, the mismatch you are seeing is between ty and literal, and they both look to be treated the same.

[RalfJung]

OTOH, the implementation for Const also does some weird stuff:

impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::Const<'tcx> {
    fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
        let ty = self.ty.fold_with(folder);
        let val = self.val.fold_with(folder);
        folder.tcx().mk_const(ty::Const {
            ty,
            val
        })
    }

    fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
        folder.fold_const(*self)
    }

    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
        self.ty.visit_with(visitor) || self.val.visit_with(visitor)
    }

    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
        visitor.visit_const(self)
    }
}

In particular it implements visit_with and fold_with, which does not usually seem to be done? Does it do that correctly (not calling the super_* methods, in particular)?

[eddyb]

@RalfJung All of that is fine. ty::Const is "unusual" because it's one of the 3 "entities" (Ty and ty::Region have the same treatment).

I'm already fixing this. MIR construction is just wrong and likely has been since forever.
MIRI kept papering over this issue by not using the ty field of ty::Const.

[eddyb]

Huh, looks like the bug is pretty recent: 5cd2806#diff-c599d3d6879ad974960a24abd4e4bdb6R953
It was introduced in #59178, after this issue - had we removed the duplication earlier, the bug would've been prevented, heh.