add map properties and fix typecheck bug

Author: mrodz

bytecode/src/function.rs

@@ -68,6 +68,12 @@ pub enum BuiltInFunction {
     FloatRound,
     FloatFloor,
     FloatCeil,
+    MapLen,
+    MapHasKey,
+    MapReplace,
+    MapKeys,
+    MapValues,
+    MapPairs,
 }
 
 type BuiltInFunctionReturnBundle = (
@@ -942,6 +948,68 @@ impl BuiltInFunction {
 
                 Ok((Some(Primitive::Float(float.ceil())), None))
             }
+            Self::MapLen => {
+                let Some(Primitive::Map(map)) = arguments.first() else {
+                    unreachable!()
+                };
+
+                Ok((
+                    Some(Primitive::Int(map.len().try_into().expect(
+                        "map length could not be stored in a 32 bit integer",
+                    ))),
+                    None,
+                ))
+            }
+            Self::MapHasKey => {
+                let (Some(Primitive::Map(map)), Some(key)) = (arguments.first(), arguments.get(1))
+                else {
+                    unreachable!()
+                };
+
+                Ok((Some(Primitive::Bool(map.contains_key(key))), None))
+            }
+            Self::MapReplace => {
+                let (Some(Primitive::Map(map)), Some(key), Some(value)) =
+                    (arguments.first(), arguments.get(1), arguments.get(2))
+                else {
+                    unreachable!()
+                };
+
+                let maybe_existing_value = map.insert(key.clone(), value.clone())?;
+                Ok((
+                    Some(Primitive::Optional(maybe_existing_value.map(Box::new))),
+                    None,
+                ))
+            }
+            Self::MapKeys => {
+                let Some(Primitive::Map(map)) = arguments.first() else {
+                    unreachable!()
+                };
+
+                Ok((Some(Primitive::Vector(GcVector::new(map.keys()))), None))
+            }
+            Self::MapValues => {
+                let Some(Primitive::Map(map)) = arguments.first() else {
+                    unreachable!()
+                };
+
+                Ok((Some(Primitive::Vector(GcVector::new(map.values()))), None))
+            }
+            Self::MapPairs => {
+                let Some(Primitive::Map(map)) = arguments.first() else {
+                    unreachable!()
+                };
+
+                Ok((
+                    Some(Primitive::Vector(GcVector::new(
+                        map.pairs()
+                            .into_iter()
+                            .map(|(key, value)| Primitive::Vector(GcVector::new(vec![key, value])))
+                            .collect::<Vec<_>>(),
+                    ))),
+                    None,
+                ))
+            }
         }
     }
 }

bytecode/src/instruction.rs

@@ -170,7 +170,8 @@ pub mod implementations {
                 .context("there must be a value at the top of the stack for a `bin_op_assign`")?;
 
             let result = {
-                let no_mut: &Primitive = value;
+                let no_hp = value.move_out_of_heap_primitive_borrow()?;
+                let no_mut: &Primitive = &no_hp;
 
                 match op.as_str() {
                     "+=" => (&*bundle.primitive() + no_mut)?,
@@ -187,7 +188,8 @@ pub mod implementations {
         } else {
             let value = ctx
                 .pop()
-                .context("there must be a value at the top of the stack for a `bin_op_assign`")?;
+                .context("there must be a value at the top of the stack for a `bin_op_assign`")?
+                .move_out_of_heap_primitive()?;
 
             let Some(maybe_ptr) = ctx.get_last_op_item_mut() else {
                 bail!("`bin_op_assign` without a name argument will attempt to modify a pointer that is second to last on the stack, but no primitive was there");
@@ -1461,7 +1463,8 @@ pub mod implementations {
          */
         #[allow(clippy::mutable_key_type)]
         let raw_map = if let Some(first) = args.first() {
-            let capacity = str::parse::<usize>(first).context("could not parse usize for map capacity")?;
+            let capacity =
+                str::parse::<usize>(first).context("could not parse usize for map capacity")?;
             HashMap::with_capacity(capacity)
         } else {
             HashMap::new()
@@ -1486,25 +1489,32 @@ pub mod implementations {
 
         let key = ctx.load_local(key_register)?;
 
-        map.insert(key.primitive().clone(), ctx.pop().expect("no value in the op stack"))?;
+        map.insert(
+            key.primitive().clone(),
+            ctx.pop().expect("no value in the op stack"),
+        )?;
 
         Ok(())
     }
 
-    
     #[inline(always)]
     pub(crate) fn map_op(ctx: &mut Ctx, args: &[String]) -> Result<()> {
         let map_register = args.first().context("no map register arg")?;
 
         let index_key = ctx.pop().context("no index in the stack")?;
 
-        let map = ctx.load_local(map_register).with_context(|| format!("no map at register {map_register}"))?;
+        let map = ctx
+            .load_local(map_register)
+            .with_context(|| format!("no map at register {map_register}"))?;
 
         let Primitive::Map(map) = &*map.primitive() else {
-            bail!("not a map")
+            bail!("{} is not a map", map.primitive())
         };
 
-        ctx.push(Primitive::HeapPrimitive(HeapPrimitive::MapPtr(map.clone(), Box::new(index_key))));
+        ctx.push(Primitive::HeapPrimitive(HeapPrimitive::MapPtr(
+            map.clone(),
+            Box::new(index_key),
+        )));
 
         Ok(())
     }

bytecode/src/stack.rs

@@ -125,7 +125,12 @@ static_module_generator! {
     float_round(BuiltInFunction::FloatRound),
     float_floor(BuiltInFunction::FloatFloor),
     float_ceil(BuiltInFunction::FloatCeil),
-
+    map_len(BuiltInFunction::MapLen),
+    map_contains_key(BuiltInFunction::MapHasKey),
+    map_replace(BuiltInFunction::MapReplace),
+    map_keys(BuiltInFunction::MapKeys),
+    map_values(BuiltInFunction::MapValues),
+    map_pairs(BuiltInFunction::MapPairs),
 }
 
 impl PrimitiveFlagsPair {

bytecode/src/variables/ops/add.rs

@@ -1,4 +1,4 @@
-use crate::variables::Primitive::{self, *};
+use crate::variables::Primitive::*;
 use crate::*;
 use anyhow::{bail, Result};
 

bytecode/src/variables/ops/bitops.rs

@@ -1,4 +1,4 @@
-use crate::variables::Primitive::{self, *};
+use crate::variables::Primitive::*;
 use crate::*;
 use anyhow::{bail, Context, Result};
 

bytecode/src/variables/ops/div.rs

@@ -1,4 +1,4 @@
-use crate::variables::Primitive::{self, *};
+use crate::variables::Primitive::*;
 use crate::*;
 use anyhow::{bail, Result};
 

bytecode/src/variables/ops/mul.rs

@@ -1,4 +1,4 @@
-use crate::variables::Primitive::{self, *};
+use crate::variables::Primitive::*;
 use crate::*;
 use anyhow::{bail, Result};
 

bytecode/src/variables/ops/ord.rs

@@ -1,4 +1,3 @@
-use crate::variables::Primitive;
 use crate::*;
 use std::cmp::Ordering;
 

bytecode/src/variables/ops/rem.rs

@@ -1,4 +1,4 @@
-use crate::variables::Primitive::{self, *};
+use crate::variables::Primitive::*;
 use crate::*;
 use anyhow::{bail, Result};
 

bytecode/src/variables/ops/sub.rs

@@ -1,4 +1,3 @@
-use crate::variables::Primitive;
 use crate::*;
 use anyhow::{bail, Result};