How to give Hashmap entries references to each other?

Question

I am trying to implement the JVM in Rust as a fun project but I am struggling with an issue involving references. When classes are loaded from class files, their references to other classes are represented as Strings. After the loading phase, a JVM should link classes with actual references to each other. I cannot figure out how to do this with Rust's references. Here is a stripped down version of what I am trying to achieve. (an MCV example)

use ClassRef::{Symbolic, Static};
use std::collections::HashMap;

fn main() {
    let mut loader = ClassLoader { classes: HashMap::new() };
    loader.load_class("java/lang/String", "java/lang/Object");
    // java.lang.Object is the only class without a direct superclass
    loader.load_class("java/lang/Object", "");
    loader.link_classes();
}

struct ClassLoader<'a> {
    classes: HashMap<String, Class<'a>>
}

impl<'a> ClassLoader<'a> {
    pub fn load_class(&mut self, name: &str, super_name: &str) {
        self.classes.insert(name.to_owned(), Class::new(name, super_name));
    }

    pub fn link_classes(&mut self) {
        // Issue 1: Editing the stored class requires a mutable borrow
        for (name, class) in self.classes.iter_mut() {
            // Issue 2: I am not allowed to move this value to itself
            class.super_class = match class.super_class {
                // Issue 3: Storing a reference to another value in the map
                Symbolic(ref super_name) => Static(self.classes.get(super_name)),
                a => a
            }
        }
    }
}

struct Class<'a> {
    super_class: ClassRef<'a>,
    name: String
}

impl<'a> Class<'a> {
    pub fn new(name: &str, super_name: &str) -> Self {
        Class {
            name: name.to_owned(),
            super_class: Symbolic(super_name.to_owned())
        }
    }
}

enum ClassRef<'a> {
    Symbolic(String),
    Static(Option<&'a Class<'a>>)
}

Currently, there are three issues with the process that I am unable to solve.

First, when I iterate through the list of loaded classes, I need to be able to change the field Class#super_class, so I need a mutable iterator. This means that I have a mutable borrow on self.classes. I also need an immutable borrow on self.classes during the iteration to look up a reference to the superclass. The way I feel like this should be solved is having a way of proving to the compiler that I am not mutating the map itself, but only a key. I feel like it has to do with std::cell::Cell as shown in Choosing your Guarantees, but the examples seem so simple I don't know how to correlate it to what I am trying to do here.

Second, I need the previous value of Class#super_class in order to calculate the new one. Essentially, I am moving the previous value out, changing it, and then moving it back in. I feel like this could be solved with some sort of higher order Map function to work on the value in place, but once again I'm not sure.

Third, when I give one class a reference to another class, there is no way of proving to the compiler that the other class won't be removed from the hashmap, causing the reference to point to deallocated memory. When classes are loaded, one class name will always point to the same class and classes are never unloaded, so I know that the value will always be there. The way I think this should be solved is with a Hashmap implementation which doesn't allow values to be overwritten or removed. I tried to poke around for such a thing but I couldn't find it.

EDIT: Solution

The duplicates linked were certainly helpful, but I ended up not using reference counting pointers (Rc<>) because the relationships between classes can sometimes be cyclic, so trying to drop the ClassLoader would end up leaking memory. The solution I settled on is using an immutable reference to a Typed-Arena allocator. This allocator is an insertion only allocator which ensures the references it distributes are valid for the entire life of the reference to the allocator, as long as said reference is immutable. I then used the hashmap to store the references. That way everything is dropped when I drop the ClassLoader. Hopefully anyone that trying to implement a relationship similar to this finds the following code helpful.

extern crate typed_arena;

use ClassRef::{Symbolic, Static};
use std::collections::HashMap;
use std::cell::RefCell;
use core::borrow::BorrowMut;
use typed_arena::Arena;

fn main() {
    let mut loader = ClassLoader { class_map: HashMap::new(), classes: &Arena::new() };
    loader.load_class("java/lang/String", "java/lang/Object");
    // java.lang.Object is the only class without a direct superclass
    loader.load_class("java/lang/Object", "");
    loader.link_classes();
}

struct ClassLoader<'a> {
    classes: &'a Arena<RefCell<Class<'a>>>,
    class_map: HashMap<String, &'a RefCell<Class<'a>>>
}

impl<'a> ClassLoader<'a> {
    pub fn load_class(&mut self, name: &str, super_name: &str) {
        let super_opt = if super_name.len() > 0 {
            Some(super_name)
        } else {
            None
        };
        let class = Class::new(name, super_opt);
        let class_ref = self.classes.alloc(RefCell::new(class));
        self.class_map.insert(name.to_owned(), class_ref);
    }

    pub fn link_classes(&mut self) {
        for (_name, class_ref) in &self.class_map {
            let mut class = (*class_ref).borrow_mut();
            if let Some(Symbolic(super_name)) = &class.super_class {
                let super_class = self.class_map.get(super_name);
                let super_class = super_class.map(|c| Static(c.clone()));
                *class.super_class.borrow_mut() = super_class;
            }
        }
    }
}

struct Class<'a> {
    super_class: Option<ClassRef<'a>>,
    name: String
}

impl<'a> Class<'a> {
    pub fn new(name: &str, super_name: Option<&str>) -> Self {
        Class {
            name: name.to_owned(),
            super_class: super_name.map(|name| Symbolic(name.to_owned()))
        }
    }
}

enum ClassRef<'a> {
    Symbolic(String),
    Static(&'a RefCell<Class<'a>>)
}