What is the meaning of "expected constant `host` found constant `true`"?

I tried writting const trait to process a const Bitmap field generation, but I got this error message:
error message:

$ rustc --edition 2021 test.rs
error[E0308]: mismatched types
  --> test.rs:37:17
   |
37 |                 res.set_false(val);
   |                 ^^^^^^^^^^^^^^^^^^ expected `host`, found `true`
   |
   = note: expected constant `host`
              found constant `true`

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0308`.

I have no idea what the function really need, the rustc --explain E0308 command does not explain the difference between constant host and constant true

How should I correct the code?


code

#![allow(incomplete_features)]
#![feature(generic_const_exprs, const_mut_refs, const_slice_first_last, let_chains, const_trait_impl, effects)]
#[const_trait]
trait Byte {
    const BITS:usize;
    const MIN:Self;
    const MAX:Self;
    fn get(&self, idx:usize)->bool;
    fn set_true(&mut self, idx:usize);
    fn set_false(&mut self, idx:usize);
}
impl Byte for u128 {
    const BITS:usize=Self::BITS as usize;
    const MIN:Self=Self::MIN;
    const MAX:Self=Self::MAX;
    fn get(&self, idx:usize)->bool{
        self&(1<<idx)!=0
    }
    fn set_true(&mut self, idx:usize){
        *self|=1<<idx
    }
    fn set_false(&mut self, idx:usize){
        *self&=!(1<<idx)
    }
}
#[derive(Clone,Copy)]
struct BitMap<const N:usize, Bit:Byte=u128>([Bit;N.div_ceil(Bit::BITS)]) where [(); N.div_ceil(Bit::BITS) ]:Sized;
impl<const N:usize,Bit:Byte> BitMap<N,Bit> where [(); N.div_ceil(Bit::BITS) ]:Sized{
    pub const FALSE:Self=Self([Bit::MIN;N.div_ceil(Bit::BITS)]);
    // pub const TRUE:Self=Self([Bit::MAX;N.div_ceil(Bit::BITS)]);
    pub const TRUE:Self=Self::gen_true();
    const fn gen_true()->Self{
        let mut ret=Self([Bit::MAX;N.div_ceil(Bit::BITS)]);
        if N.div_ceil(Bit::BITS)*Bit::BITS-N>0 && let Some(res)=ret.0.last_mut() {
            let mut val:usize=N&(Bit::BITS-1);
            while val<Bit::BITS {
                res.set_false(val);
                val+=1;
            }
        }
        ret
    }
}
impl<const N:usize,Bit:Byte> core::fmt::Debug for BitMap<N,Bit> where [(); N.div_ceil(Bit::BITS) ]:Sized {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        if self.0.len()>1 {
            for i in 0..(self.0.len()-1) {
                let res=&self.0[i];
                for j in 0..Bit::BITS {
                    if res.get(j) {
                        f.write_str("T")?;
                    } else {
                        f.write_str("F")?;
                    }
                }
                f.write_str("\n")?;
            }
            let res=&self.0[self.0.len()-1];
            let sep=N-(N.div_ceil(Bit::BITS)-1)*Bit::BITS;
            for j in 0..sep {
                if res.get(j) {
                    f.write_str("T")?;
                } else {
                    f.write_str("F")?;
                }
            }
            for j in sep..Bit::BITS {
                if res.get(j) {
                    f.write_str("t")?;
                } else {
                    f.write_str("f")?;
                }
            }
        }
        f.write_str("")
    }
}
fn main(){
    let a=BitMap::<600>::TRUE;
    println!("{a:?}")
}

The error message looks like a bug in one of the unstable const features you are using to me. My guess would be const_trait_impl.