Context with Rc<Refcell<T>> reducer type has unexpected behavior about yew HOT 1 OPEN

struct ChatroomContext(UseReducerHandle<StateData>);
impl PartialEq for ChatroomContext {
    fn eq(&self, other: &Self) { false }
}
...
        <ContextProvider<ChatroomContext> context={ChatroomContext(state)} >
...

pub struct SharedState {
    pub open: bool, // etc..
}
#[derive(Clone)]
pub struct StateData {
    generation: u32,
    pub state: Rc<RefCell<SharedState>>,
}
impl PartialEq for StateData {
    fn eq(&self, other: &Self) -> bool {
        // this assumes that there is only one history for each state, which is true in use_reducer
        Rc::ptr_eq(&self.state, &other.state) && self.generation == other.generation
    }
}
impl StateData {
    // small helper method to facilitate incrementing the generation counter
    fn mutate<'a>(self: &'a mut Rc<Self>) -> impl 'a + DerefMut<Target = SharedState> {
        // We can cheaply clone ourself. With some further work you can write this without
        // leaking the `Clone` impl for StateData
        let this = Rc::make_mut(self);
        // Since we are borrowing mutably, we assume that the data "changed" and we increase the generation
        this.generation += 1;
        this.state.borrow_mut()
    }
}
impl Reducible for StateData {
    type Action = StateAction;

    fn reduce(mut self: Rc<Self>, action: Self::Action) -> Rc<Self> {
        match action {
            StateAction::SetPreviewOpen(x) => {
                let mut state = StateData::mutate(&mut self);
                state.open = x;
            }
        }
        self
    }
}
....
        // This context provider will see the same shared state, but different generation numbers
        // On subsequent re-renders, it will trigger re-renders of downstream when the generation changed
        <ContextProvider<ChatroomContext> context={state} >
....