first steps for init

compiler/can/src/builtins.rs

@@ -82,6 +82,7 @@ pub fn builtin_defs_map(symbol: Symbol, var_store: &mut VarStore) -> Option<Def>
         DICT_TEST_HASH => dict_hash_test_only,
         DICT_LEN => dict_len,
         DICT_EMPTY => dict_empty,
+        DICT_INSERT => dict_insert,
         NUM_ADD => num_add,
         NUM_ADD_CHECKED => num_add_checked,
         NUM_ADD_WRAP => num_add_wrap,
@@ -180,6 +181,7 @@ pub fn builtin_defs(var_store: &mut VarStore) -> MutMap<Symbol, Def> {
         Symbol::DICT_TEST_HASH => dict_hash_test_only,
         Symbol::DICT_LEN => dict_len,
         Symbol::DICT_EMPTY => dict_empty,
+        Symbol::DICT_INSERT => dict_insert,
         Symbol::NUM_ADD => num_add,
         Symbol::NUM_ADD_CHECKED => num_add_checked,
         Symbol::NUM_ADD_WRAP => num_add_wrap,
@@ -1896,6 +1898,35 @@ fn dict_empty(symbol: Symbol, var_store: &mut VarStore) -> Def {
     }
 }
 
+/// Dict.insert : Dict k v, k, v -> Dict k v
+fn dict_insert(symbol: Symbol, var_store: &mut VarStore) -> Def {
+    let dict_var = var_store.fresh();
+    let key_var = var_store.fresh();
+    let val_var = var_store.fresh();
+
+    let body = RunLowLevel {
+        op: LowLevel::DictInsert,
+        args: vec![
+            (dict_var, Var(Symbol::ARG_1)),
+            (key_var, Var(Symbol::ARG_2)),
+            (val_var, Var(Symbol::ARG_3)),
+        ],
+        ret_var: dict_var,
+    };
+
+    defn(
+        symbol,
+        vec![
+            (dict_var, Symbol::ARG_1),
+            (key_var, Symbol::ARG_2),
+            (val_var, Symbol::ARG_3),
+        ],
+        var_store,
+        body,
+        dict_var,
+    )
+}
+
 /// Num.rem : Int, Int -> Result Int [ DivByZero ]*
 fn num_rem(symbol: Symbol, var_store: &mut VarStore) -> Def {
     let num_var = var_store.fresh();

compiler/gen/src/llvm/build.rs

@@ -1,4 +1,4 @@
-use crate::llvm::build_dict::{dict_empty, dict_len};
+use crate::llvm::build_dict::{dict_empty, dict_insert, dict_len};
 use crate::llvm::build_hash::hash;
 use crate::llvm::build_list::{
     allocate_list, empty_list, empty_polymorphic_list, list_append, list_concat, list_contains,
@@ -3998,6 +3998,14 @@ fn run_low_level<'a, 'ctx, 'env>(
             debug_assert_eq!(args.len(), 0);
             dict_empty(env, scope)
         }
+        DictInsert => {
+            debug_assert_eq!(args.len(), 3);
+
+            let (dict, _) = load_symbol_and_layout(scope, &args[0]);
+            let (key, key_layout) = load_symbol_and_layout(scope, &args[1]);
+            let (value, value_layout) = load_symbol_and_layout(scope, &args[2]);
+            dict_insert(env, scope, dict, key, key_layout, value, value_layout)
+        }
     }
 }
 

compiler/gen/src/llvm/build_dict.rs

@@ -50,6 +50,18 @@ pub fn dict_empty<'a, 'ctx, 'env>(
     zig_dict_to_struct(env, result).into()
 }
 
+pub fn dict_insert<'a, 'ctx, 'env>(
+    _env: &Env<'a, 'ctx, 'env>,
+    _scope: &Scope<'a, 'ctx>,
+    _dict: BasicValueEnum<'ctx>,
+    _key: BasicValueEnum<'ctx>,
+    _key_layout: &Layout<'a>,
+    _value: BasicValueEnum<'ctx>,
+    _value_layout: &Layout<'a>,
+) -> BasicValueEnum<'ctx> {
+    todo!()
+}
+
 fn dict_symbol_to_i128<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,
     scope: &Scope<'a, 'ctx>,

compiler/module/src/low_level.rs

@@ -30,6 +30,7 @@ pub enum LowLevel {
     ListSum,
     DictSize,
     DictEmpty,
+    DictInsert,
     NumAdd,
     NumAddWrap,
     NumAddChecked,

compiler/mono/src/borrow.rs

@@ -591,5 +591,6 @@ pub fn lowlevel_borrow_signature(arena: &Bump, op: LowLevel) -> &[bool] {
         Hash => arena.alloc_slice_copy(&[borrowed, irrelevant]),
         DictSize => arena.alloc_slice_copy(&[borrowed]),
         DictEmpty => &[],
+        DictInsert => arena.alloc_slice_copy(&[owned, owned, owned]),
     }
 }