Added LIST_REVERSE symbol and an untested implementation in build.rs

compiler/gen/src/llvm/build.rs

@@ -1529,7 +1529,6 @@ fn call_with_args<'a, 'ctx, 'env>(
                 );
 
                 builder.build_store(start_alloca, next_index);
-
                 let elem_ptr =
                     unsafe { builder.build_in_bounds_gep(list_ptr, &[curr_index], "load_index") };
 
@@ -1591,6 +1590,146 @@ fn call_with_args<'a, 'ctx, 'env>(
                 BasicTypeEnum::StructType(struct_type),
             )
         }
+        Symbol::LIST_REVERSE => {
+            // List.reverse : List elem -> List elem
+            debug_assert_eq!(args.len(), 1);
+
+            let (list, list_layout) = &args[0];
+
+            let builder = env.builder;
+            let ctx = env.context;
+
+            let list_len = load_list_len(builder, list.into_struct_value());
+
+            // list_len > 0
+            // We have to do a loop below, continuously adding the `elem`
+            // to the output list `List elem` until we have reached the
+            // number of repeats. This `comparison` is used to check
+            // if we need to do any looping; because if we dont, then we
+            // dont need to allocate memory for the index or the check
+            // if list_len == 0
+            let comparison = builder.build_int_compare(
+                IntPredicate::EQ,
+                list_len,
+                ctx.i64_type().const_int(0, false),
+                "atleastzero",
+            );
+
+            let build_then = || {
+                // Allocate space for the new array that we'll copy into.
+                let elem_bytes = elem_layout.stack_size(env.ptr_bytes) as u64;
+
+                match list_layout {
+                    Layout::Builtin(Builtin::List(elem_layout)) => {
+                        let list_ptr = {
+                            let len_type = env.ptr_int();
+                            let len = len_type.const_int(elem_bytes, false);
+
+                            let elem_type =
+                                basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
+
+                            env.builder
+                                .build_array_malloc(elem_type, len, "create_list_ptr")
+                                .unwrap()
+
+                            // TODO check if malloc returned null; if so, runtime error for OOM!
+                        };
+
+                        let index_name = "#index";
+                        let start_alloca = builder.build_alloca(ctx.i64_type(), index_name);
+
+                        builder.build_store(start_alloca, list_len);
+
+                        let loop_bb = ctx.append_basic_block(parent, "loop");
+                        builder.build_unconditional_branch(loop_bb);
+                        builder.position_at_end(loop_bb);
+
+                        // #index = #index - 1
+                        let curr_index = builder
+                            .build_load(start_alloca, index_name)
+                            .into_int_value();
+                        let next_index = builder.build_int_sub(
+                            curr_index,
+                            ctx.i64_type().const_int(1, false),
+                            "nextindex",
+                        );
+
+                        builder.build_store(start_alloca, next_index);
+
+                        let elem_ptr = unsafe {
+                            builder.build_in_bounds_gep(list_ptr, &[curr_index], "load_index")
+                        };
+
+                        // Mutate the new array in-place to change the element.
+                        // builder.build_store(elem_ptr, builder.build_load(elem_ptr, "List.get"));
+                        builder.build_store(elem_ptr, curr_index);
+
+                        // #index != 0
+                        let end_cond = builder.build_int_compare(
+                            IntPredicate::NE,
+                            ctx.i64_type().const_int(0, false),
+                            curr_index,
+                            "loopcond",
+                        );
+
+                        let after_bb = ctx.append_basic_block(parent, "afterloop");
+
+                        builder.build_conditional_branch(end_cond, loop_bb, after_bb);
+                        builder.position_at_end(after_bb);
+
+                        let ptr_bytes = env.ptr_bytes;
+                        let int_type = ptr_int(ctx, ptr_bytes);
+                        let ptr_as_int =
+                            builder.build_ptr_to_int(list_ptr, int_type, "list_cast_ptr");
+                        let struct_type = collection(ctx, ptr_bytes);
+
+                        let mut struct_val;
+
+                        // Store the pointer
+                        struct_val = builder
+                            .build_insert_value(
+                                struct_type.get_undef(),
+                                ptr_as_int,
+                                Builtin::WRAPPER_PTR,
+                                "insert_ptr",
+                            )
+                            .unwrap();
+
+                        // Store the length
+                        struct_val = builder
+                            .build_insert_value(
+                                struct_val,
+                                list_len,
+                                Builtin::WRAPPER_LEN,
+                                "insert_len",
+                            )
+                            .unwrap();
+
+                        builder.build_bitcast(
+                            struct_val.into_struct_value(),
+                            collection(ctx, ptr_bytes),
+                            "cast_collection",
+                        )
+                    }
+                    _ => {
+                        unreachable!("Invalid List layout for List.get: {:?}", list_layout);
+                    }
+                }
+            };
+
+            let build_else = || empty_list(env);
+
+            let struct_type = collection(ctx, env.ptr_bytes);
+
+            build_basic_phi2(
+                env,
+                parent,
+                comparison,
+                build_then,
+                build_else,
+                BasicTypeEnum::StructType(struct_type),
+            )
+        }
         Symbol::INT_DIV_UNSAFE => {
             debug_assert!(args.len() == 2);