intercal/not-python-rust
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

WIP: move mutability to be internal to the object instead of the pointer

Browse Source 
I'm not super happy with this. But, the RwLock has been moved to the
`BaseObjInst::attrs` member. Although this is not exactly how it appears
in code, it basically does this:

    type Ptr<T> = Arc<RwLock<T>>;

    struct BaseObjInst {
        attr: HashMap<String, Ptr<dyn Obj>>,
        // etc
    }

becomes

    type Ptr<T> = Arc<T>;

    struct BaseObjInst {
        attr: RwLock<HashMap<String, ObjP>>,
        // etc
    }

This makes things a lot more ergonomic (don't have to use try_read() and
try_write() everywhere), but it also eliminates compile-time errors that
would catch mutability errors. This is currently rearing its ugly head
when initializing the typesystem, since `Type` needs to hold a circular
reference itself (which it already shouldn't be doing since it's a
reference-counted pointer!). Currently, all tests are failing because of
this limitation.

There are a couple of ways around this limitation.

The first solution would be just copying  all of the object
instantiation code into the `init_types` function and avoid calling
`some_base_type.instantiate()`. This would probably be literal
copy-pasting, or maybe an (ugly) macro, and probably a nightmare to
maintain long-term. I don't like this option, but it would make
everything "just work" with reference-counted pointers.

The second solution would be to write our own garbage collector, which
would allow for circular references and (hypothetically) mutably
updating these references. This is something that I am looking into,
because I really want a RefCell that you can pass around in a more
ergonomic way.

I think the fundamental error that I'm running into is trying to borrow
the same value multiple times mutably, which you *really* shouldn't be
doing. I believe I need to write better code and does the same thing.

The only unsolved problem is circular references. This is not a problem
right now because I'm not writing code that has circular references
besides the base typesystem (which is not a problem because they need to
live the entire lifetime of the program), but it will be a latent
problem until it gets fixed.

Signed-off-by: Alek Ratzloff <alekratz@gmail.com>
This commit is contained in:
Alek Ratzloff
2024-09-22 20:40:15 -07:00
parent 16f3dc960c
commit 24b06851c7
5 changed files with 76 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/disassemble.rs
View File

@@ -33,7 +33,7 @@ fn disassemble_chunk(chunk: &Chunk, constants: &Vec<ObjP>, globals: &Vec<String>
}
Op::PushConstant(constant_id) => {
op_str = "PUSH_CONSTANT";
arg = format!("{}", &constants[*constant_id as usize].try_read().unwrap());
arg = format!("{}", &constants[*constant_id as usize]);
info = format!("(constant ID {constant_id})");
}
Op::GetLocal(local_id) => {
@@ -60,12 +60,12 @@ fn disassemble_chunk(chunk: &Chunk, constants: &Vec<ObjP>, globals: &Vec<String>
}
Op::GetAttr(constant_id) => {
op_str = "GET_ATTR";
arg = format!("{}", &constants[*constant_id as usize].try_read().unwrap());
arg = format!("{}", &constants[*constant_id as usize]);
info = format!("(constant ID {constant_id})");
}
Op::SetAttr(constant_id) => {
op_str = "SET_ATTR";
arg = format!("{}", &constants[*constant_id as usize].try_read().unwrap());
arg = format!("{}", &constants[*constant_id as usize]);
info = format!("(constant ID {constant_id})");
}
Op::Jump(jump_offset) => {
@@ -145,8 +145,7 @@ pub fn disassemble(chunk: &Chunk, constants: &Vec<ObjP>, globals: &Vec<String>)
disassemble_chunk(chunk, constants, globals);
for constant in constants {
let borrowed = constant.try_read().unwrap();
if let Some(fun) = borrowed.as_any().downcast_ref::<UserFunctionInst>() {
if let Some(fun) = constant.as_any().downcast_ref::<UserFunctionInst>() {
println!();
println!(
"== {} starting on line {}",