From d1cfb5d8f92178bcc1395cca672392fd10ab2034 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 12 Nov 2024 20:00:53 +0100
Subject: [PATCH 01/40] Target: Add listData() method

---
 include/scratchcpp/target.h          |  2 ++
 src/scratch/target.cpp               | 26 ++++++++++++++++++++++++++
 src/scratch/target_p.h               |  2 ++
 test/scratch_classes/target_test.cpp |  8 ++++++++
 4 files changed, 38 insertions(+)

diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index b9d89eb5..20d1a389 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -53,6 +53,8 @@ class LIBSCRATCHCPP_EXPORT Target : public Drawable
         int findList(const std::string &listName) const;
         int findListById(const std::string &id) const;
 
+        List **listData();
+
         const std::vector<std::shared_ptr<Block>> &blocks() const;
         int addBlock(std::shared_ptr<Block> block);
         std::shared_ptr<Block> blockAt(int index) const;
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index c25b2f38..aa555d74 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -150,6 +150,7 @@ int Target::addList(std::shared_ptr<List> list)
         return it - impl->lists.begin();
 
     impl->lists.push_back(list);
+    impl->listDataDirty = true;
     list->setTarget(this);
 
     return impl->lists.size() - 1;
@@ -186,6 +187,31 @@ int Target::findListById(const std::string &id) const
         return it - impl->lists.begin();
 }
 
+/*! Returns an array of list pointers (for optimized list access). */
+List **Target::listData()
+{
+    if (impl->listDataDirty) {
+        const size_t len = impl->lists.size();
+
+        if (len == 0) {
+            impl->listDataDirty = false;
+            return nullptr;
+        }
+
+        if (impl->listData)
+            impl->listData = (List **)realloc(impl->listData, len * sizeof(List *));
+        else
+            impl->listData = (List **)malloc(len * sizeof(List *));
+
+        for (size_t i = 0; i < len; i++)
+            impl->listData[i] = impl->lists[i].get();
+
+        impl->listDataDirty = false;
+    }
+
+    return impl->listData;
+}
+
 /*! Returns the list of blocks. */
 const std::vector<std::shared_ptr<Block>> &Target::blocks() const
 {
diff --git a/src/scratch/target_p.h b/src/scratch/target_p.h
index fc18bfb8..1261330a 100644
--- a/src/scratch/target_p.h
+++ b/src/scratch/target_p.h
@@ -31,6 +31,8 @@ struct TargetPrivate
         bool variableDataDirty = true;
         ValueData **variableData = nullptr;
         std::vector<std::shared_ptr<List>> lists;
+        bool listDataDirty = true;
+        List **listData = nullptr;
         std::vector<std::shared_ptr<Block>> blocks;
         std::vector<std::shared_ptr<Comment>> comments;
         int costumeIndex = -1;
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index f83f46fa..93ef3330 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -119,9 +119,17 @@ TEST(TargetTest, Lists)
 
     Target target;
     ASSERT_EQ(target.addList(l1), 0);
+    ASSERT_TRUE(target.listData());
+    ASSERT_EQ(target.listData()[0], l1.get());
     ASSERT_EQ(target.addList(l2), 1);
     ASSERT_EQ(target.addList(l3), 2);
+    ASSERT_EQ(target.listData()[0], l1.get());
+    ASSERT_EQ(target.listData()[1], l2.get());
+    ASSERT_EQ(target.listData()[2], l3.get());
     ASSERT_EQ(target.addList(l2), 1); // add existing list
+    ASSERT_EQ(target.listData()[0], l1.get());
+    ASSERT_EQ(target.listData()[1], l2.get());
+    ASSERT_EQ(target.listData()[2], l3.get());
 
     ASSERT_EQ(l1->target(), &target);
     ASSERT_EQ(l2->target(), &target);

From a22f8d308b89972638b2529abaf147a25e15227b Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 12 Nov 2024 20:03:37 +0100
Subject: [PATCH 02/40] LLVMCodeBuilder: Initial list limplementation

---
 src/dev/engine/internal/llvm/CMakeLists.txt   |  1 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 57 ++++++++++++++++++-
 .../engine/internal/llvm/llvmcodebuilder.h    |  7 +++
 .../internal/llvm/llvmexecutablecode.cpp      |  2 +-
 .../engine/internal/llvm/llvmexecutablecode.h |  3 +-
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 src/dev/engine/internal/llvm/llvmlistptr.h    | 23 ++++++++
 test/dev/llvm/llvmcodebuilder_test.cpp        |  2 +-
 test/dev/llvm/llvmexecutablecode_test.cpp     | 19 +++++--
 test/dev/llvm/testfunctions.cpp               |  4 +-
 test/dev/llvm/testfunctions.h                 |  3 +-
 test/dev/llvm/testmock.h                      |  4 +-
 12 files changed, 111 insertions(+), 15 deletions(-)
 create mode 100644 src/dev/engine/internal/llvm/llvmlistptr.h

diff --git a/src/dev/engine/internal/llvm/CMakeLists.txt b/src/dev/engine/internal/llvm/CMakeLists.txt
index a7833f5b..1a4ce89a 100644
--- a/src/dev/engine/internal/llvm/CMakeLists.txt
+++ b/src/dev/engine/internal/llvm/CMakeLists.txt
@@ -9,6 +9,7 @@ target_sources(scratchcpp
     llvmcoroutine.cpp
     llvmcoroutine.h
     llvmvariableptr.h
+    llvmlistptr.h
     llvmprocedure.h
     llvmtypes.cpp
     llvmtypes.h
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 5a304a71..46153824 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -8,6 +8,7 @@
 #include <scratchcpp/stage.h>
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 
 #include "llvmcodebuilder.h"
 #include "llvmexecutablecode.h"
@@ -36,6 +37,7 @@ LLVMCodeBuilder::LLVMCodeBuilder(Target *target, const std::string &id, bool war
     m_regs.push_back({});
     initTypes();
     createVariableMap();
+    createListMap();
 }
 
 std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
@@ -56,12 +58,13 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     m_builder.setFastMathFlags(fmf);
 
     // Create function
-    // void *f(Target *, ValueData **)
+    // void *f(Target *, ValueData **, List **)
     llvm::PointerType *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-    llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, { pointerType, pointerType }, false);
+    llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, { pointerType, pointerType, pointerType }, false);
     llvm::Function *func = llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "f", m_module.get());
     llvm::Value *targetPtr = func->getArg(0);
     llvm::Value *targetVariables = func->getArg(1);
+    llvm::Value *targetLists = func->getArg(2);
 
     llvm::BasicBlock *entry = llvm::BasicBlock::Create(m_ctx, "entry", func);
     m_builder.SetInsertPoint(entry);
@@ -92,6 +95,10 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     m_scopeVariables.clear();
     m_scopeVariables.push_back({});
 
+    // Create list pointers
+    for (auto &[list, listPtr] : m_listPtrs)
+        listPtr.ptr = getListPtr(targetLists, list);
+
     // Execute recorded steps
     for (const LLVMInstruction &step : m_instructions) {
         switch (step.type) {
@@ -1031,6 +1038,36 @@ void LLVMCodeBuilder::createVariableMap()
     }
 }
 
+void LLVMCodeBuilder::createListMap()
+{
+    if (!m_target)
+        return;
+
+    // Map list pointers to list array indices
+    const auto &lists = m_target->lists();
+    List **listData = m_target->listData();
+    const size_t len = lists.size();
+    m_targetListMap.clear();
+    m_targetListMap.reserve(len);
+
+    size_t i, j;
+
+    for (i = 0; i < len; i++) {
+        List *list = lists[i].get();
+
+        // Find this list
+        for (j = 0; j < len; j++) {
+            if (listData[j] == list)
+                break;
+        }
+
+        if (j < len)
+            m_targetListMap[list] = j;
+        else
+            assert(false);
+    }
+}
+
 void LLVMCodeBuilder::pushScopeLevel()
 {
     m_scopeVariables.push_back({});
@@ -1315,6 +1352,22 @@ llvm::Value *LLVMCodeBuilder::getVariablePtr(llvm::Value *targetVariables, Varia
     return m_builder.CreateIntToPtr(addr, m_valueDataType->getPointerTo());
 }
 
+llvm::Value *LLVMCodeBuilder::getListPtr(llvm::Value *targetLists, List *list)
+{
+    if (!m_target->isStage() && list->target() == m_target) {
+        // If this is a local sprite list, use the list array at runtime (for clones)
+        assert(m_targetListMap.find(list) != m_targetListMap.cend());
+        const size_t index = m_targetListMap[list];
+        auto pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+        llvm::Value *ptr = m_builder.CreateGEP(pointerType, targetLists, m_builder.getInt64(index));
+        return m_builder.CreateLoad(pointerType, ptr);
+    }
+
+    // Otherwise create a raw pointer at compile time
+    llvm::Value *addr = m_builder.getInt64((uintptr_t)list);
+    return m_builder.CreateIntToPtr(addr, m_valueDataType->getPointerTo());
+}
+
 void LLVMCodeBuilder::syncVariables(llvm::Value *targetVariables)
 {
     // Copy stack variables to the actual variables
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index 6117b02f..4dc501f8 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -11,6 +11,7 @@
 #include "llvminstruction.h"
 #include "llvmcoroutine.h"
 #include "llvmvariableptr.h"
+#include "llvmlistptr.h"
 
 namespace libscratchcpp
 {
@@ -83,6 +84,7 @@ class LLVMCodeBuilder : public ICodeBuilder
 
         void initTypes();
         void createVariableMap();
+        void createListMap();
         void pushScopeLevel();
         void popScopeLevel();
 
@@ -99,6 +101,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::Value *removeNaN(llvm::Value *num);
 
         llvm::Value *getVariablePtr(llvm::Value *targetVariables, Variable *variable);
+        llvm::Value *getListPtr(llvm::Value *targetLists, List *list);
         void syncVariables(llvm::Value *targetVariables);
         void reloadVariables(llvm::Value *targetVariables);
 
@@ -132,10 +135,14 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
+
         std::unordered_map<Variable *, size_t> m_targetVariableMap;
         std::unordered_map<Variable *, LLVMVariablePtr> m_variablePtrs;
         std::vector<std::unordered_map<LLVMVariablePtr *, Compiler::StaticType>> m_scopeVariables;
 
+        std::unordered_map<List *, size_t> m_targetListMap;
+        std::unordered_map<List *, LLVMListPtr> m_listPtrs;
+
         std::string m_id;
         llvm::LLVMContext m_ctx;
         std::unique_ptr<llvm::Module> m_module;
diff --git a/src/dev/engine/internal/llvm/llvmexecutablecode.cpp b/src/dev/engine/internal/llvm/llvmexecutablecode.cpp
index 3357be56..eb8b8b03 100644
--- a/src/dev/engine/internal/llvm/llvmexecutablecode.cpp
+++ b/src/dev/engine/internal/llvm/llvmexecutablecode.cpp
@@ -55,7 +55,7 @@ void LLVMExecutableCode::run(ExecutionContext *context)
         ctx->setFinished(done);
     } else {
         Target *target = ctx->target();
-        void *handle = m_mainFunction(target, target->variableData());
+        void *handle = m_mainFunction(target, target->variableData(), target->listData());
 
         if (!handle)
             ctx->setFinished(true);
diff --git a/src/dev/engine/internal/llvm/llvmexecutablecode.h b/src/dev/engine/internal/llvm/llvmexecutablecode.h
index e066cd9c..26e412dd 100644
--- a/src/dev/engine/internal/llvm/llvmexecutablecode.h
+++ b/src/dev/engine/internal/llvm/llvmexecutablecode.h
@@ -11,6 +11,7 @@ namespace libscratchcpp
 {
 
 class Target;
+class List;
 class LLVMExecutionContext;
 
 class LLVMExecutableCode : public ExecutableCode
@@ -32,7 +33,7 @@ class LLVMExecutableCode : public ExecutableCode
     private:
         uint64_t lookupFunction(const std::string &name);
 
-        using MainFunctionType = void *(*)(Target *, ValueData **);
+        using MainFunctionType = void *(*)(Target *, ValueData **, List **);
         using ResumeFunctionType = bool (*)(void *);
 
         static LLVMExecutionContext *getContext(ExecutionContext *context);
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index 41186cad..32267518 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -63,6 +63,7 @@ struct LLVMInstruction
         std::vector<std::pair<Compiler::StaticType, LLVMRegisterPtr>> args; // target type, register
         LLVMRegisterPtr functionReturnReg;
         Variable *workVariable = nullptr; // for variables
+        List *workList = nullptr;         // for lists
 };
 
 } // namespace libscratchcpp
diff --git a/src/dev/engine/internal/llvm/llvmlistptr.h b/src/dev/engine/internal/llvm/llvmlistptr.h
new file mode 100644
index 00000000..9dc93ec4
--- /dev/null
+++ b/src/dev/engine/internal/llvm/llvmlistptr.h
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <scratchcpp/dev/compiler.h>
+
+namespace llvm
+{
+
+class Value;
+
+}
+
+namespace libscratchcpp
+{
+
+struct LLVMListPtr
+{
+        llvm::Value *ptr = nullptr;
+        Compiler::StaticType type = Compiler::StaticType::Unknown;
+};
+
+} // namespace libscratchcpp
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index 58e467d4..743cb969 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -20,7 +20,7 @@ class LLVMCodeBuilderTest : public testing::Test
     public:
         void SetUp() override
         {
-            test_function(nullptr, nullptr); // force dependency
+            test_function(nullptr, nullptr, nullptr, nullptr); // force dependency
         }
 
         void createBuilder(Target *target, bool warp) { m_builder = std::make_unique<LLVMCodeBuilder>(target, "test", warp); }
diff --git a/test/dev/llvm/llvmexecutablecode_test.cpp b/test/dev/llvm/llvmexecutablecode_test.cpp
index 8af37328..84e86d15 100644
--- a/test/dev/llvm/llvmexecutablecode_test.cpp
+++ b/test/dev/llvm/llvmexecutablecode_test.cpp
@@ -1,5 +1,7 @@
 #include <scratchcpp/target.h>
 #include <scratchcpp/value_functions.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 #include <dev/engine/internal/llvm/llvmexecutablecode.h>
 #include <dev/engine/internal/llvm/llvmexecutioncontext.h>
 #include <llvm/Support/TargetSelect.h>
@@ -18,7 +20,7 @@ class LLVMExecutableCodeTest : public testing::Test
         {
             m_module = std::make_unique<llvm::Module>("test", m_ctx);
             m_builder = std::make_unique<llvm::IRBuilder<>>(m_ctx);
-            test_function(nullptr, nullptr); // force dependency
+            test_function(nullptr, nullptr, nullptr, nullptr); // force dependency
 
             llvm::InitializeNativeTarget();
             llvm::InitializeNativeTargetAsmPrinter();
@@ -29,7 +31,7 @@ class LLVMExecutableCodeTest : public testing::Test
 
         llvm::Function *beginMainFunction()
         {
-            // void *f(Target *, ValueData **, ValueData **)
+            // void *f(Target *, ValueData **, List **)
             llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
             llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, { pointerType, pointerType, pointerType }, false);
             llvm::Function *func = llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "f", m_module.get());
@@ -55,12 +57,12 @@ class LLVMExecutableCodeTest : public testing::Test
         void addTestFunction(llvm::Function *mainFunc)
         {
             auto ptrType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-            auto func = m_module->getOrInsertFunction("test_function", llvm::FunctionType::get(m_builder->getVoidTy(), { ptrType, ptrType }, false));
+            auto func = m_module->getOrInsertFunction("test_function", llvm::FunctionType::get(m_builder->getVoidTy(), { ptrType, ptrType, ptrType, ptrType }, false));
 
             llvm::Constant *mockInt = llvm::ConstantInt::get(llvm::Type::getInt64Ty(m_ctx), (uintptr_t)&m_mock, false);
             llvm::Constant *mockPtr = llvm::ConstantExpr::getIntToPtr(mockInt, ptrType);
 
-            m_builder->CreateCall(func, { mockPtr, mainFunc->getArg(0) });
+            m_builder->CreateCall(func, { mockPtr, mainFunc->getArg(0), mainFunc->getArg(1), mainFunc->getArg(2) });
         }
 
         void addTestPrintFunction(llvm::Value *arg1, llvm::Value *arg2)
@@ -94,6 +96,9 @@ TEST_F(LLVMExecutableCodeTest, CreateExecutionContext)
 
 TEST_F(LLVMExecutableCodeTest, MainFunction)
 {
+    m_target.addVariable(std::make_shared<Variable>("", ""));
+    m_target.addList(std::make_shared<List>("", ""));
+
     auto f = beginMainFunction();
     addTestFunction(f);
     endFunction(nullPointer());
@@ -105,7 +110,7 @@ TEST_F(LLVMExecutableCodeTest, MainFunction)
     auto ctx = code.createExecutionContext(&m_target);
     ASSERT_FALSE(code.isFinished(ctx.get()));
 
-    EXPECT_CALL(m_mock, f(&m_target));
+    EXPECT_CALL(m_mock, f(&m_target, m_target.variableData(), m_target.listData()));
     code.run(ctx.get());
     ASSERT_TRUE(code.isFinished(ctx.get()));
 
@@ -124,11 +129,13 @@ TEST_F(LLVMExecutableCodeTest, MainFunction)
 
     // Test with another context
     Target anotherTarget;
+    anotherTarget.addVariable(std::make_shared<Variable>("", ""));
+    anotherTarget.addList(std::make_shared<List>("", ""));
     auto anotherCtx = code.createExecutionContext(&anotherTarget);
     ASSERT_FALSE(code.isFinished(anotherCtx.get()));
     ASSERT_TRUE(code.isFinished(ctx.get()));
 
-    EXPECT_CALL(m_mock, f(&anotherTarget));
+    EXPECT_CALL(m_mock, f(&anotherTarget, anotherTarget.variableData(), anotherTarget.listData()));
     code.run(anotherCtx.get());
     ASSERT_TRUE(code.isFinished(anotherCtx.get()));
     ASSERT_TRUE(code.isFinished(ctx.get()));
diff --git a/test/dev/llvm/testfunctions.cpp b/test/dev/llvm/testfunctions.cpp
index 86ecb8b6..8555ee24 100644
--- a/test/dev/llvm/testfunctions.cpp
+++ b/test/dev/llvm/testfunctions.cpp
@@ -11,10 +11,10 @@ static int counter = 0;
 
 extern "C"
 {
-    void test_function(TestMock *mock, Target *target)
+    void test_function(TestMock *mock, Target *target, ValueData **varData, List **listData)
     {
         if (mock)
-            mock->f(target);
+            mock->f(target, varData, listData);
     }
 
     void test_print_function(ValueData *arg1, ValueData *arg2)
diff --git a/test/dev/llvm/testfunctions.h b/test/dev/llvm/testfunctions.h
index 94f8a76a..c20c8efa 100644
--- a/test/dev/llvm/testfunctions.h
+++ b/test/dev/llvm/testfunctions.h
@@ -6,10 +6,11 @@ namespace libscratchcpp
 class TestMock;
 class Target;
 class ValueData;
+class List;
 
 extern "C"
 {
-    void test_function(TestMock *mock, Target *target);
+    void test_function(TestMock *mock, Target *target, ValueData **varData, List **listData);
     void test_print_function(ValueData *arg1, ValueData *arg2);
 
     void test_function_no_args(Target *target);
diff --git a/test/dev/llvm/testmock.h b/test/dev/llvm/testmock.h
index 9b26d1fa..176eeff2 100644
--- a/test/dev/llvm/testmock.h
+++ b/test/dev/llvm/testmock.h
@@ -6,11 +6,13 @@ namespace libscratchcpp
 {
 
 class Target;
+struct ValueData;
+class List;
 
 class TestMock
 {
     public:
-        MOCK_METHOD(void, f, (Target *));
+        MOCK_METHOD(void, f, (Target *, ValueData **, List **));
 };
 
 } // namespace libscratchcpp

From 8d0d24fccb10998cc6f60d36eb6ef1235b559fa6 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 12 Nov 2024 21:36:11 +0100
Subject: [PATCH 03/40] Add list_clear() function

---
 src/scratch/CMakeLists.txt                   |  2 ++
 src/scratch/list_functions.cpp               | 15 +++++++++++++++
 src/scratch/list_functions.h                 | 15 +++++++++++++++
 test/scratch_classes/CMakeLists.txt          |  1 +
 test/scratch_classes/list_functions_test.cpp | 16 ++++++++++++++++
 5 files changed, 49 insertions(+)
 create mode 100644 src/scratch/list_functions.cpp
 create mode 100644 src/scratch/list_functions.h
 create mode 100644 test/scratch_classes/list_functions_test.cpp

diff --git a/src/scratch/CMakeLists.txt b/src/scratch/CMakeLists.txt
index 926cb2b0..71d6c8c0 100644
--- a/src/scratch/CMakeLists.txt
+++ b/src/scratch/CMakeLists.txt
@@ -14,6 +14,8 @@ target_sources(scratchcpp
     list.cpp
     list_p.cpp
     list_p.h
+    list_functions.cpp
+    list_functions.h
     block.cpp
     block_p.cpp
     block_p.h
diff --git a/src/scratch/list_functions.cpp b/src/scratch/list_functions.cpp
new file mode 100644
index 00000000..a5ecb988
--- /dev/null
+++ b/src/scratch/list_functions.cpp
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <scratchcpp/list.h>
+
+#include "list_functions.h"
+
+using namespace libscratchcpp;
+
+extern "C"
+{
+    void list_clear(List *list)
+    {
+        list->clear();
+    }
+}
diff --git a/src/scratch/list_functions.h b/src/scratch/list_functions.h
new file mode 100644
index 00000000..89fc702d
--- /dev/null
+++ b/src/scratch/list_functions.h
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace libscratchcpp
+{
+
+class List;
+
+extern "C"
+{
+    void list_clear(List *list);
+}
+
+} // namespace libscratchcpp
diff --git a/test/scratch_classes/CMakeLists.txt b/test/scratch_classes/CMakeLists.txt
index 279727bb..511cf190 100644
--- a/test/scratch_classes/CMakeLists.txt
+++ b/test/scratch_classes/CMakeLists.txt
@@ -16,6 +16,7 @@ gtest_discover_tests(blockprototype_test)
 add_executable(
   list_test
   list_test.cpp
+  list_functions_test.cpp
 )
 
 target_link_libraries(
diff --git a/test/scratch_classes/list_functions_test.cpp b/test/scratch_classes/list_functions_test.cpp
new file mode 100644
index 00000000..56a9e3e2
--- /dev/null
+++ b/test/scratch_classes/list_functions_test.cpp
@@ -0,0 +1,16 @@
+#include <scratchcpp/list.h>
+#include <scratch/list_functions.h>
+
+#include <gtest/gtest.h>
+
+using namespace libscratchcpp;
+
+TEST(ListFunctionsTest, Clear)
+{
+    List list("", "");
+    list.append(1);
+    list.append(2);
+    list.append(3);
+
+    list_clear(&list);
+}

From 6ad13ee2a691ddc923743650ca3c04621e1b832d Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 12 Nov 2024 21:49:32 +0100
Subject: [PATCH 04/40] LLVMCodeBuilder: Implement list clear

---
 src/dev/engine/internal/icodebuilder.h        |  2 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 20 +++++
 .../engine/internal/llvm/llvmcodebuilder.h    |  3 +
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        | 75 +++++++++++++++++++
 test/mocks/codebuildermock.h                  |  2 +
 6 files changed, 103 insertions(+)

diff --git a/src/dev/engine/internal/icodebuilder.h b/src/dev/engine/internal/icodebuilder.h
index 8ca7fbea..2e373a36 100644
--- a/src/dev/engine/internal/icodebuilder.h
+++ b/src/dev/engine/internal/icodebuilder.h
@@ -56,6 +56,8 @@ class ICodeBuilder
 
         virtual void createVariableWrite(Variable *variable) = 0;
 
+        virtual void createListClear(List *list) = 0;
+
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
         virtual void endIf() = 0;
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 46153824..93606c14 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -477,6 +477,13 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::ClearList: {
+                assert(step.args.size() == 0);
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                m_builder.CreateCall(resolve_list_clear(), listPtr.ptr);
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -932,6 +939,13 @@ void LLVMCodeBuilder::createVariableWrite(Variable *variable)
     m_variablePtrs[variable] = LLVMVariablePtr();
 }
 
+void LLVMCodeBuilder::createListClear(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::ClearList, Compiler::StaticType::Void, Compiler::StaticType::Void, 0);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     LLVMInstruction ins(LLVMInstruction::Type::BeginIf);
@@ -1822,6 +1836,12 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_value_lower()
     return resolveFunction("value_lower", llvm::FunctionType::get(m_builder.getInt1Ty(), { valuePtr, valuePtr }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_clear()
+{
+    llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("list_clear", llvm::FunctionType::get(m_builder.getInt1Ty(), { listPtr }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
 {
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index 4dc501f8..6fefad72 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -62,6 +62,8 @@ class LLVMCodeBuilder : public ICodeBuilder
 
         void createVariableWrite(Variable *variable) override;
 
+        void createListClear(List *list) override;
+
         void beginIfStatement() override;
         void beginElseBranch() override;
         void endIf() override;
@@ -132,6 +134,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_value_equals();
         llvm::FunctionCallee resolve_value_greater();
         llvm::FunctionCallee resolve_value_lower();
+        llvm::FunctionCallee resolve_list_clear();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index 32267518..300f3c11 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -42,6 +42,7 @@ struct LLVMInstruction
             Exp10,
             WriteVariable,
             ReadVariable,
+            ClearList,
             Yield,
             BeginIf,
             BeginElse,
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index 743cb969..61c82a13 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -3,6 +3,7 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 #include <dev/engine/internal/llvm/llvmcodebuilder.h>
 #include <gmock/gmock.h>
 #include <targetmock.h>
@@ -1899,6 +1900,80 @@ TEST_F(LLVMCodeBuilderTest, ReadVariable)
     ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
 }
 
+TEST_F(LLVMCodeBuilderTest, ClearList)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    std::unordered_map<List *, std::string> strings;
+
+    auto globalList1 = std::make_shared<List>("", "");
+    auto globalList2 = std::make_shared<List>("", "");
+    auto globalList3 = std::make_shared<List>("", "");
+    stage.addList(globalList1);
+    stage.addList(globalList2);
+    stage.addList(globalList3);
+
+    auto localList1 = std::make_shared<List>("", "");
+    auto localList2 = std::make_shared<List>("", "");
+    auto localList3 = std::make_shared<List>("", "");
+    sprite.addList(localList1);
+    sprite.addList(localList2);
+    sprite.addList(localList3);
+
+    globalList1->append(1);
+    globalList1->append(2);
+    globalList1->append(3);
+    strings[globalList1.get()] = globalList1->toString();
+
+    globalList2->append("Lorem");
+    globalList2->append("ipsum");
+    globalList2->append(-4.52);
+    strings[globalList2.get()] = globalList2->toString();
+
+    globalList3->append(true);
+    globalList3->append(false);
+    globalList3->append(true);
+    strings[globalList3.get()] = globalList3->toString();
+
+    localList1->append("dolor");
+    localList1->append("sit");
+    localList1->append("amet");
+    strings[localList1.get()] = localList1->toString();
+
+    localList2->append(10);
+    localList2->append(9.8);
+    localList2->append(true);
+    strings[localList2.get()] = localList2->toString();
+
+    localList3->append("test");
+    localList3->append(1.2);
+    localList3->append(false);
+    strings[localList3.get()] = localList3->toString();
+
+    createBuilder(&sprite, true);
+
+    m_builder->createListClear(globalList1.get());
+    m_builder->createListClear(globalList3.get());
+    m_builder->createListClear(localList1.get());
+    m_builder->createListClear(localList2.get());
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    code->run(ctx.get());
+
+    ASSERT_TRUE(globalList1->empty());
+    ASSERT_EQ(globalList2->toString(), strings[globalList2.get()]);
+    ASSERT_TRUE(globalList3->empty());
+
+    ASSERT_TRUE(localList1->empty());
+    ASSERT_TRUE(localList2->empty());
+    ASSERT_EQ(localList3->toString(), strings[localList3.get()]);
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
index 0028f76b..6589d1b0 100644
--- a/test/mocks/codebuildermock.h
+++ b/test/mocks/codebuildermock.h
@@ -46,6 +46,8 @@ class CodeBuilderMock : public ICodeBuilder
 
         MOCK_METHOD(void, createVariableWrite, (Variable *), (override));
 
+        MOCK_METHOD(void, createListClear, (List *), (override));
+
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));
         MOCK_METHOD(void, endIf, (), (override));

From 06f551e588b089a7be74a3bc62caad22a92e579d Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 14 Nov 2024 20:55:20 +0100
Subject: [PATCH 05/40] Compiler: Add custom if statement methods

---
 include/scratchcpp/dev/compiler.h   |  4 +++
 src/dev/engine/compiler.cpp         | 39 +++++++++++++++++++++++++++--
 src/dev/engine/compiler_p.h         |  1 +
 test/dev/compiler/compiler_test.cpp | 22 ++++++++++++++++
 4 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/include/scratchcpp/dev/compiler.h b/include/scratchcpp/dev/compiler.h
index f5b2c7fb..fa6550c8 100644
--- a/include/scratchcpp/dev/compiler.h
+++ b/include/scratchcpp/dev/compiler.h
@@ -80,6 +80,10 @@ class LIBSCRATCHCPP_EXPORT Compiler
 
         void createVariableWrite(Variable *variable);
 
+        void beginIfStatement();
+        void beginElseBranch();
+        void endIf();
+
         void moveToIf(std::shared_ptr<Block> substack);
         void moveToIfElse(std::shared_ptr<Block> substack1, std::shared_ptr<Block> substack2);
         void moveToRepeatLoop(std::shared_ptr<Block> substack);
diff --git a/src/dev/engine/compiler.cpp b/src/dev/engine/compiler.cpp
index 1dde27ab..ed225ff2 100644
--- a/src/dev/engine/compiler.cpp
+++ b/src/dev/engine/compiler.cpp
@@ -45,9 +45,15 @@ std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBl
     impl->block = startBlock;
 
     while (impl->block) {
-        if (impl->block->compileFunction())
+        if (impl->block->compileFunction()) {
+            assert(impl->customIfStatementCount == 0);
             impl->block->compile(this);
-        else {
+
+            if (impl->customIfStatementCount > 0) {
+                std::cerr << "error: if statement created by block '" << impl->block->opcode() << "' not terminated" << std::endl;
+                assert(false);
+            }
+        } else {
             std::cout << "warning: unsupported block: " << impl->block->opcode() << std::endl;
             impl->unsupportedBlocks.insert(impl->block->opcode());
         }
@@ -262,6 +268,35 @@ void Compiler::createVariableWrite(Variable *variable)
     impl->builder->createVariableWrite(variable);
 }
 
+/*!
+ * Starts a custom if statement.
+ * \note The if statement must be terminated using endIf() after compiling your block.
+ */
+void Compiler::beginIfStatement()
+{
+    impl->builder->beginIfStatement();
+    impl->customIfStatementCount++;
+}
+
+/*! Starts the else branch of custom if statement. */
+void Compiler::beginElseBranch()
+{
+    impl->builder->beginElseBranch();
+}
+
+/*! Ends custom if statement. */
+void Compiler::endIf()
+{
+    if (impl->customIfStatementCount == 0) {
+        std::cerr << "error: called Compiler::endIf() without an if statement";
+        assert(false);
+        return;
+    }
+
+    impl->builder->endIf();
+    impl->customIfStatementCount--;
+}
+
 /*! Jumps to the given if substack. */
 void Compiler::moveToIf(std::shared_ptr<Block> substack)
 {
diff --git a/src/dev/engine/compiler_p.h b/src/dev/engine/compiler_p.h
index 059d143b..0a23d71d 100644
--- a/src/dev/engine/compiler_p.h
+++ b/src/dev/engine/compiler_p.h
@@ -31,6 +31,7 @@ struct CompilerPrivate
         Target *target = nullptr;
 
         std::shared_ptr<Block> block;
+        int customIfStatementCount = 0;
         std::vector<std::pair<std::pair<std::shared_ptr<Block>, std::shared_ptr<Block>>, SubstackType>> substackTree;
         bool substackHit = false;
         bool warp = false;
diff --git a/test/dev/compiler/compiler_test.cpp b/test/dev/compiler/compiler_test.cpp
index e20ab74a..822eb358 100644
--- a/test/dev/compiler/compiler_test.cpp
+++ b/test/dev/compiler/compiler_test.cpp
@@ -571,6 +571,28 @@ TEST_F(CompilerTest, CreateVariableWrite)
     compile(compiler, block);
 }
 
+TEST_F(CompilerTest, CustomIfStatement)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, beginIfStatement());
+        compiler->beginIfStatement();
+        EXPECT_CALL(*m_builder, endIf());
+        compiler->endIf();
+
+        EXPECT_CALL(*m_builder, beginIfStatement());
+        compiler->beginIfStatement();
+        EXPECT_CALL(*m_builder, beginElseBranch());
+        compiler->beginElseBranch();
+        EXPECT_CALL(*m_builder, endIf());
+        compiler->endIf();
+    });
+
+    compile(compiler, block);
+}
+
 TEST_F(CompilerTest, MoveToIf)
 {
     Compiler compiler(&m_engine, &m_target);

From c304971f11507278c44ad11afa1b7ec09102c472 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 16 Nov 2024 17:24:09 +0100
Subject: [PATCH 06/40] Add list_remove() function

---
 src/scratch/list_functions.cpp               |  5 +++++
 src/scratch/list_functions.h                 |  3 +++
 test/scratch_classes/list_functions_test.cpp | 21 ++++++++++++++++++++
 3 files changed, 29 insertions(+)

diff --git a/src/scratch/list_functions.cpp b/src/scratch/list_functions.cpp
index a5ecb988..aaa5a81d 100644
--- a/src/scratch/list_functions.cpp
+++ b/src/scratch/list_functions.cpp
@@ -12,4 +12,9 @@ extern "C"
     {
         list->clear();
     }
+
+    void list_remove(List *list, size_t index)
+    {
+        list->removeAt(index);
+    }
 }
diff --git a/src/scratch/list_functions.h b/src/scratch/list_functions.h
index 89fc702d..75d75860 100644
--- a/src/scratch/list_functions.h
+++ b/src/scratch/list_functions.h
@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include <cstddef>
+
 namespace libscratchcpp
 {
 
@@ -10,6 +12,7 @@ class List;
 extern "C"
 {
     void list_clear(List *list);
+    void list_remove(List *list, size_t index);
 }
 
 } // namespace libscratchcpp
diff --git a/test/scratch_classes/list_functions_test.cpp b/test/scratch_classes/list_functions_test.cpp
index 56a9e3e2..583ea4ec 100644
--- a/test/scratch_classes/list_functions_test.cpp
+++ b/test/scratch_classes/list_functions_test.cpp
@@ -14,3 +14,24 @@ TEST(ListFunctionsTest, Clear)
 
     list_clear(&list);
 }
+
+TEST(ListFunctionsTest, Remove)
+{
+    List list("", "test list");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+
+    list_remove(&list, 1);
+    ASSERT_EQ(list.toString(), "Lorem dolor sit amet");
+    list_remove(&list, 3);
+    ASSERT_EQ(list.toString(), "Lorem dolor sit");
+    list_remove(&list, 0);
+    ASSERT_EQ(list.toString(), "dolor sit");
+    list_remove(&list, 1);
+    ASSERT_EQ(list.toString(), "dolor");
+    list_remove(&list, 0);
+    ASSERT_TRUE(list.empty());
+}

From 57574c4e4e7a72e81891f3686b1518e797a83582 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 16 Nov 2024 17:40:27 +0100
Subject: [PATCH 07/40] LLVMCodeBuilder: Implement remove list item

---
 src/dev/engine/internal/icodebuilder.h        |  1 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 22 ++++++++++
 .../engine/internal/llvm/llvmcodebuilder.h    |  2 +
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        | 42 +++++++++++++++++++
 test/mocks/codebuildermock.h                  |  1 +
 6 files changed, 69 insertions(+)

diff --git a/src/dev/engine/internal/icodebuilder.h b/src/dev/engine/internal/icodebuilder.h
index 2e373a36..92f7b02d 100644
--- a/src/dev/engine/internal/icodebuilder.h
+++ b/src/dev/engine/internal/icodebuilder.h
@@ -57,6 +57,7 @@ class ICodeBuilder
         virtual void createVariableWrite(Variable *variable) = 0;
 
         virtual void createListClear(List *list) = 0;
+        virtual void createListRemove(List *list) = 0;
 
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 93606c14..b75b8aee 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -484,6 +484,15 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::RemoveListItem: {
+                assert(step.args.size() == 1);
+                const auto &arg = step.args[0];
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                llvm::Value *index = m_builder.CreateFPToUI(castValue(arg.second, arg.first), m_builder.getInt64Ty());
+                m_builder.CreateCall(resolve_list_remove(), { listPtr.ptr, index });
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -946,6 +955,13 @@ void LLVMCodeBuilder::createListClear(List *list)
     m_listPtrs[list] = LLVMListPtr();
 }
 
+void LLVMCodeBuilder::createListRemove(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::RemoveListItem, Compiler::StaticType::Void, Compiler::StaticType::Number, 1);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     LLVMInstruction ins(LLVMInstruction::Type::BeginIf);
@@ -1842,6 +1858,12 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_clear()
     return resolveFunction("list_clear", llvm::FunctionType::get(m_builder.getInt1Ty(), { listPtr }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_remove()
+{
+    llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("list_remove", llvm::FunctionType::get(m_builder.getInt1Ty(), { listPtr, m_builder.getInt64Ty() }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
 {
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index 6fefad72..e576d262 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -63,6 +63,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createVariableWrite(Variable *variable) override;
 
         void createListClear(List *list) override;
+        void createListRemove(List *list) override;
 
         void beginIfStatement() override;
         void beginElseBranch() override;
@@ -135,6 +136,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_value_greater();
         llvm::FunctionCallee resolve_value_lower();
         llvm::FunctionCallee resolve_list_clear();
+        llvm::FunctionCallee resolve_list_remove();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index 300f3c11..2dfce2af 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -43,6 +43,7 @@ struct LLVMInstruction
             WriteVariable,
             ReadVariable,
             ClearList,
+            RemoveListItem,
             Yield,
             BeginIf,
             BeginElse,
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index 61c82a13..a969d9f6 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -1974,6 +1974,48 @@ TEST_F(LLVMCodeBuilderTest, ClearList)
     ASSERT_EQ(localList3->toString(), strings[localList3.get()]);
 }
 
+TEST_F(LLVMCodeBuilderTest, RemoveFromList)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    std::unordered_map<List *, std::string> strings;
+
+    auto globalList = std::make_shared<List>("", "");
+    stage.addList(globalList);
+
+    auto localList = std::make_shared<List>("", "");
+    sprite.addList(localList);
+
+    globalList->append(1);
+    globalList->append(2);
+    globalList->append(3);
+
+    localList->append("Lorem");
+    localList->append("ipsum");
+    localList->append("dolor");
+    localList->append("sit");
+    strings[localList.get()] = localList->toString();
+
+    createBuilder(&sprite, true);
+
+    m_builder->addConstValue(1);
+    m_builder->createListRemove(globalList.get());
+
+    m_builder->addConstValue(3);
+    m_builder->createListRemove(localList.get());
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    code->run(ctx.get());
+
+    ASSERT_EQ(globalList->toString(), "13");
+    ASSERT_EQ(localList->toString(), "Lorem ipsum dolor");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
index 6589d1b0..ee884e21 100644
--- a/test/mocks/codebuildermock.h
+++ b/test/mocks/codebuildermock.h
@@ -47,6 +47,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, createVariableWrite, (Variable *), (override));
 
         MOCK_METHOD(void, createListClear, (List *), (override));
+        MOCK_METHOD(void, createListRemove, (List *), (override));
 
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));

From ef19574292297c242a5e42ef4a5237c173c5f12f Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 16 Nov 2024 18:27:14 +0100
Subject: [PATCH 08/40] LLVMCodeBuilder: Fix return types of list functions

---
 src/dev/engine/internal/llvm/llvmcodebuilder.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index b75b8aee..a409e7bd 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -1855,13 +1855,13 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_value_lower()
 llvm::FunctionCallee LLVMCodeBuilder::resolve_list_clear()
 {
     llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-    return resolveFunction("list_clear", llvm::FunctionType::get(m_builder.getInt1Ty(), { listPtr }, false));
+    return resolveFunction("list_clear", llvm::FunctionType::get(m_builder.getVoidTy(), { listPtr }, false));
 }
 
 llvm::FunctionCallee LLVMCodeBuilder::resolve_list_remove()
 {
     llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-    return resolveFunction("list_remove", llvm::FunctionType::get(m_builder.getInt1Ty(), { listPtr, m_builder.getInt64Ty() }, false));
+    return resolveFunction("list_remove", llvm::FunctionType::get(m_builder.getVoidTy(), { listPtr, m_builder.getInt64Ty() }, false));
 }
 
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()

From 4901aa0c5d216fdb97eedec872b4570982f47f93 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 16 Nov 2024 20:27:13 +0100
Subject: [PATCH 09/40] LLVMCodeBuilder: Fix value type field index

---
 src/dev/engine/internal/llvm/llvmcodebuilder.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index a409e7bd..1102e42b 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -1466,7 +1466,7 @@ void LLVMCodeBuilder::createValueStore(LLVMRegisterPtr reg, llvm::Value *targetP
                 case Compiler::StaticType::Bool: {
                     // Write number to bool value directly and change type
                     llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 0);
-                    llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 0);
+                    llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 1);
                     m_builder.CreateStore(converted, ptr);
                     m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(mappedType)), typePtr);
                     break;
@@ -1485,7 +1485,7 @@ void LLVMCodeBuilder::createValueStore(LLVMRegisterPtr reg, llvm::Value *targetP
                     // Write bool to number value directly and change type
                     llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 0);
                     m_builder.CreateStore(converted, ptr);
-                    llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 0);
+                    llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 1);
                     m_builder.CreateStore(converted, ptr);
                     m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(mappedType)), typePtr);
                     break;

From 9e790d08859cdcb409ec83c63241b71cf2b02336 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 16 Nov 2024 22:03:50 +0100
Subject: [PATCH 10/40] Add value_append_empty() function

---
 src/scratch/list_functions.cpp               |  5 +++++
 src/scratch/list_functions.h                 |  3 +++
 test/scratch_classes/list_functions_test.cpp | 17 +++++++++++++++++
 3 files changed, 25 insertions(+)

diff --git a/src/scratch/list_functions.cpp b/src/scratch/list_functions.cpp
index aaa5a81d..e46000f5 100644
--- a/src/scratch/list_functions.cpp
+++ b/src/scratch/list_functions.cpp
@@ -17,4 +17,9 @@ extern "C"
     {
         list->removeAt(index);
     }
+
+    ValueData *list_append_empty(List *list)
+    {
+        return &list->appendEmpty();
+    }
 }
diff --git a/src/scratch/list_functions.h b/src/scratch/list_functions.h
index 75d75860..40c6c996 100644
--- a/src/scratch/list_functions.h
+++ b/src/scratch/list_functions.h
@@ -8,11 +8,14 @@ namespace libscratchcpp
 {
 
 class List;
+struct ValueData;
 
 extern "C"
 {
     void list_clear(List *list);
     void list_remove(List *list, size_t index);
+
+    ValueData *list_append_empty(List *list);
 }
 
 } // namespace libscratchcpp
diff --git a/test/scratch_classes/list_functions_test.cpp b/test/scratch_classes/list_functions_test.cpp
index 583ea4ec..5bc5941e 100644
--- a/test/scratch_classes/list_functions_test.cpp
+++ b/test/scratch_classes/list_functions_test.cpp
@@ -35,3 +35,20 @@ TEST(ListFunctionsTest, Remove)
     list_remove(&list, 0);
     ASSERT_TRUE(list.empty());
 }
+
+TEST(ListFunctionsTest, AppendEmpty)
+{
+    List list("", "test list");
+    list.append("Lorem");
+    list.append("ipsum");
+
+    ValueData *v = list_append_empty(&list);
+    value_init(v);
+    value_assign_double(v, 5);
+    ASSERT_EQ(list.toString(), "Lorem ipsum 5");
+
+    v = list_append_empty(&list);
+    value_init(v);
+    value_assign_string(v, "test");
+    ASSERT_EQ(list.toString(), "Lorem ipsum 5 test");
+}

From fd3cc6c603b30d1cbe367d1cb371458db910d28a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sat, 16 Nov 2024 22:07:44 +0100
Subject: [PATCH 11/40] LLVMCodeBuilder: Implement list append

---
 src/dev/engine/internal/icodebuilder.h        |  1 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 59 +++++++++++++++++++
 .../engine/internal/llvm/llvmcodebuilder.h    |  3 +
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        | 56 ++++++++++++++++++
 test/mocks/codebuildermock.h                  |  1 +
 6 files changed, 121 insertions(+)

diff --git a/src/dev/engine/internal/icodebuilder.h b/src/dev/engine/internal/icodebuilder.h
index 92f7b02d..7fcbd8d8 100644
--- a/src/dev/engine/internal/icodebuilder.h
+++ b/src/dev/engine/internal/icodebuilder.h
@@ -58,6 +58,7 @@ class ICodeBuilder
 
         virtual void createListClear(List *list) = 0;
         virtual void createListRemove(List *list) = 0;
+        virtual void createListAppend(List *list) = 0;
 
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 1102e42b..36c5aeb7 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -493,6 +493,17 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::AppendToList: {
+                assert(step.args.size() == 1);
+                const auto &arg = step.args[0];
+                Compiler::StaticType type = optimizeRegisterType(arg.second);
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                llvm::Value *itemPtr = m_builder.CreateCall(resolve_list_append_empty(), listPtr.ptr);
+                createInitialValueStore(arg.second, itemPtr, type);
+                // TODO: Implement list type prediction
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -962,6 +973,13 @@ void LLVMCodeBuilder::createListRemove(List *list)
     m_listPtrs[list] = LLVMListPtr();
 }
 
+void LLVMCodeBuilder::createListAppend(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::AppendToList, Compiler::StaticType::Void, Compiler::StaticType::Unknown, 1);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     LLVMInstruction ins(LLVMInstruction::Type::BeginIf);
@@ -1519,6 +1537,41 @@ void LLVMCodeBuilder::createValueStore(LLVMRegisterPtr reg, llvm::Value *targetP
     }
 }
 
+void LLVMCodeBuilder::createInitialValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType)
+{
+    llvm::Value *converted = nullptr;
+
+    if (sourceType != Compiler::StaticType::Unknown)
+        converted = castValue(reg, sourceType);
+
+    auto it = std::find_if(TYPE_MAP.begin(), TYPE_MAP.end(), [sourceType](const std::pair<ValueType, Compiler::StaticType> &pair) { return pair.second == sourceType; });
+    const ValueType mappedType = it == TYPE_MAP.cend() ? ValueType::Number : it->first; // unknown type can be ignored
+
+    llvm::Value *valuePtr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 0);
+    llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, targetPtr, 1);
+    m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(mappedType)), typePtr);
+
+    switch (sourceType) {
+        case Compiler::StaticType::Number:
+        case Compiler::StaticType::Bool:
+            // Write number/bool directly
+            m_builder.CreateStore(converted, valuePtr);
+            break;
+
+        case Compiler::StaticType::String:
+            m_builder.CreateCall(resolve_value_assign_cstring(), { targetPtr, converted });
+            break;
+
+        case Compiler::StaticType::Unknown:
+            m_builder.CreateCall(resolve_value_assign_copy(), { targetPtr, reg->value });
+            break;
+
+        default:
+            assert(false);
+            break;
+    }
+}
+
 void LLVMCodeBuilder::createValueCopy(llvm::Value *source, llvm::Value *target)
 {
     // NOTE: This doesn't copy strings, but only the pointers
@@ -1864,6 +1917,12 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_remove()
     return resolveFunction("list_remove", llvm::FunctionType::get(m_builder.getVoidTy(), { listPtr, m_builder.getInt64Ty() }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_append_empty()
+{
+    llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("list_append_empty", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
 {
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index e576d262..b32d830c 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -64,6 +64,7 @@ class LLVMCodeBuilder : public ICodeBuilder
 
         void createListClear(List *list) override;
         void createListRemove(List *list) override;
+        void createListAppend(List *list) override;
 
         void beginIfStatement() override;
         void beginElseBranch() override;
@@ -111,6 +112,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         LLVMInstruction &createOp(LLVMInstruction::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount);
 
         void createValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType, Compiler::StaticType targetType);
+        void createInitialValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType);
         void createValueCopy(llvm::Value *source, llvm::Value *target);
         void copyStructField(llvm::Value *source, llvm::Value *target, int index, llvm::StructType *structType, llvm::Type *fieldType);
         llvm::Value *createValue(LLVMRegisterPtr reg);
@@ -137,6 +139,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_value_lower();
         llvm::FunctionCallee resolve_list_clear();
         llvm::FunctionCallee resolve_list_remove();
+        llvm::FunctionCallee resolve_list_append_empty();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index 2dfce2af..cd6de717 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -44,6 +44,7 @@ struct LLVMInstruction
             ReadVariable,
             ClearList,
             RemoveListItem,
+            AppendToList,
             Yield,
             BeginIf,
             BeginElse,
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index a969d9f6..ecdbd8b1 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -2016,6 +2016,62 @@ TEST_F(LLVMCodeBuilderTest, RemoveFromList)
     ASSERT_EQ(localList->toString(), "Lorem ipsum dolor");
 }
 
+TEST_F(LLVMCodeBuilderTest, AppendToList)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    std::unordered_map<List *, std::string> strings;
+
+    auto globalList = std::make_shared<List>("", "");
+    stage.addList(globalList);
+
+    auto localList = std::make_shared<List>("", "");
+    sprite.addList(localList);
+
+    globalList->append(1);
+    globalList->append(2);
+    globalList->append(3);
+
+    localList->append("Lorem");
+    localList->append("ipsum");
+    localList->append("dolor");
+    localList->append("sit");
+    strings[localList.get()] = localList->toString();
+
+    createBuilder(&sprite, true);
+
+    m_builder->addConstValue(1);
+    m_builder->createListAppend(globalList.get());
+
+    m_builder->addConstValue("test");
+    m_builder->createListAppend(globalList.get());
+
+    m_builder->addConstValue(3);
+    m_builder->createListAppend(localList.get());
+
+    m_builder->createListClear(localList.get());
+
+    m_builder->addConstValue(true);
+    m_builder->createListAppend(localList.get());
+
+    m_builder->addConstValue(false);
+    m_builder->createListAppend(localList.get());
+
+    m_builder->addConstValue("hello world");
+    m_builder->createListAppend(localList.get());
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    code->run(ctx.get());
+
+    ASSERT_EQ(globalList->toString(), "1 2 3 1 test");
+    ASSERT_EQ(localList->toString(), "true false hello world");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
index ee884e21..ee59dbfa 100644
--- a/test/mocks/codebuildermock.h
+++ b/test/mocks/codebuildermock.h
@@ -48,6 +48,7 @@ class CodeBuilderMock : public ICodeBuilder
 
         MOCK_METHOD(void, createListClear, (List *), (override));
         MOCK_METHOD(void, createListRemove, (List *), (override));
+        MOCK_METHOD(void, createListAppend, (List *), (override));
 
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));

From f5c18952a33b47516a5d7977144e503ab046f08d Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sun, 17 Nov 2024 10:11:32 +0100
Subject: [PATCH 12/40] List: Add insert_empty() method

---
 include/scratchcpp/list.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/include/scratchcpp/list.h b/include/scratchcpp/list.h
index 8ce30c85..715d093c 100644
--- a/include/scratchcpp/list.h
+++ b/include/scratchcpp/list.h
@@ -96,16 +96,19 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
             m_size--;
         }
 
-        /*! Inserts an item at index. */
-        inline void insert(size_t index, const ValueData &value)
+        /*! Inserts an empty item at index and returns the reference to it. Can be used for custom initialization. */
+        inline ValueData &insertEmpty(size_t index)
         {
             assert(index >= 0 && index <= size());
             m_size++;
             reserve(getAllocSize(m_size));
             std::rotate(m_dataPtr->rbegin() + m_dataPtr->size() - m_size, m_dataPtr->rbegin() + m_dataPtr->size() - m_size + 1, m_dataPtr->rend() - index);
-            value_assign_copy(&m_dataPtr->operator[](index), &value);
+            return m_dataPtr->operator[](index);
         }
 
+        /*! Inserts an item at index. */
+        inline void insert(size_t index, const ValueData &value) { value_assign_copy(&insertEmpty(index), &value); }
+
         /*! Inserts an item at index. */
         inline void insert(size_t index, const Value &value) { insert(index, value.data()); }
 

From 138197f805dc456a713974db4b7e1fe6d3be9caf Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sun, 17 Nov 2024 10:12:27 +0100
Subject: [PATCH 13/40] Add list_insert_empty() function

---
 src/scratch/list_functions.cpp               |  5 +++++
 src/scratch/list_functions.h                 |  1 +
 test/scratch_classes/list_functions_test.cpp | 17 +++++++++++++++++
 3 files changed, 23 insertions(+)

diff --git a/src/scratch/list_functions.cpp b/src/scratch/list_functions.cpp
index e46000f5..0fc46dc6 100644
--- a/src/scratch/list_functions.cpp
+++ b/src/scratch/list_functions.cpp
@@ -22,4 +22,9 @@ extern "C"
     {
         return &list->appendEmpty();
     }
+
+    ValueData *list_insert_empty(List *list, size_t index)
+    {
+        return &list->insertEmpty(index);
+    }
 }
diff --git a/src/scratch/list_functions.h b/src/scratch/list_functions.h
index 40c6c996..f9e13924 100644
--- a/src/scratch/list_functions.h
+++ b/src/scratch/list_functions.h
@@ -16,6 +16,7 @@ extern "C"
     void list_remove(List *list, size_t index);
 
     ValueData *list_append_empty(List *list);
+    ValueData *list_insert_empty(List *list, size_t index);
 }
 
 } // namespace libscratchcpp
diff --git a/test/scratch_classes/list_functions_test.cpp b/test/scratch_classes/list_functions_test.cpp
index 5bc5941e..93340c75 100644
--- a/test/scratch_classes/list_functions_test.cpp
+++ b/test/scratch_classes/list_functions_test.cpp
@@ -52,3 +52,20 @@ TEST(ListFunctionsTest, AppendEmpty)
     value_assign_string(v, "test");
     ASSERT_EQ(list.toString(), "Lorem ipsum 5 test");
 }
+
+TEST(ListFunctionsTest, InsertEmpty)
+{
+    List list("", "test list");
+    list.append("Lorem");
+    list.append("ipsum");
+
+    ValueData *v = list_insert_empty(&list, 0);
+    value_init(v);
+    value_assign_double(v, 5);
+    ASSERT_EQ(list.toString(), "5 Lorem ipsum");
+
+    v = list_insert_empty(&list, 2);
+    value_init(v);
+    value_assign_string(v, "test");
+    ASSERT_EQ(list.toString(), "5 Lorem test ipsum");
+}

From cf0f44080f7b37684312b0561f5658053b824a7a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sun, 17 Nov 2024 10:38:38 +0100
Subject: [PATCH 14/40] LLVMCodeBuilder: Allow different arg types in
 createOp()

---
 .../engine/internal/llvm/llvmcodebuilder.cpp    | 17 +++++++++++++++--
 src/dev/engine/internal/llvm/llvmcodebuilder.h  |  1 +
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 36c5aeb7..3f9aeab8 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -1438,14 +1438,27 @@ void LLVMCodeBuilder::reloadVariables(llvm::Value *targetVariables)
 }
 
 LLVMInstruction &LLVMCodeBuilder::createOp(LLVMInstruction::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount)
+{
+    std::vector<Compiler::StaticType> types;
+    types.reserve(argCount);
+
+    for (size_t i = 0; i < argCount; i++)
+        types.push_back(argType);
+
+    return createOp(type, retType, types, argCount);
+}
+
+LLVMInstruction &LLVMCodeBuilder::createOp(LLVMInstruction::Type type, Compiler::StaticType retType, const std::vector<Compiler::StaticType> &argTypes, size_t argCount)
 {
     LLVMInstruction ins(type);
 
     assert(m_tmpRegs.size() >= argCount);
     size_t j = 0;
 
-    for (size_t i = m_tmpRegs.size() - argCount; i < m_tmpRegs.size(); i++)
-        ins.args.push_back({ argType, m_tmpRegs[i] });
+    for (size_t i = m_tmpRegs.size() - argCount; i < m_tmpRegs.size(); i++) {
+        ins.args.push_back({ argTypes[j], m_tmpRegs[i] });
+        j++;
+    }
 
     m_tmpRegs.erase(m_tmpRegs.end() - argCount, m_tmpRegs.end());
 
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index b32d830c..c786d216 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -110,6 +110,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void reloadVariables(llvm::Value *targetVariables);
 
         LLVMInstruction &createOp(LLVMInstruction::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount);
+        LLVMInstruction &createOp(LLVMInstruction::Type type, Compiler::StaticType retType, const std::vector<Compiler::StaticType> &argTypes, size_t argCount);
 
         void createValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType, Compiler::StaticType targetType);
         void createInitialValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType);

From 14840cfc58b049b0b50b168767fe2bc29e966f54 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sun, 17 Nov 2024 10:38:59 +0100
Subject: [PATCH 15/40] LLVMCodeBuilder: Implement list insert

---
 src/dev/engine/internal/icodebuilder.h        |  1 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 26 ++++++++
 .../engine/internal/llvm/llvmcodebuilder.h    |  2 +
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        | 62 +++++++++++++++++++
 test/mocks/codebuildermock.h                  |  1 +
 6 files changed, 93 insertions(+)

diff --git a/src/dev/engine/internal/icodebuilder.h b/src/dev/engine/internal/icodebuilder.h
index 7fcbd8d8..77641a01 100644
--- a/src/dev/engine/internal/icodebuilder.h
+++ b/src/dev/engine/internal/icodebuilder.h
@@ -59,6 +59,7 @@ class ICodeBuilder
         virtual void createListClear(List *list) = 0;
         virtual void createListRemove(List *list) = 0;
         virtual void createListAppend(List *list) = 0;
+        virtual void createListInsert(List *list) = 0;
 
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 3f9aeab8..901104fa 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -504,6 +504,19 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::InsertToList: {
+                assert(step.args.size() == 2);
+                const auto &indexArg = step.args[0];
+                const auto &valueArg = step.args[1];
+                Compiler::StaticType type = optimizeRegisterType(valueArg.second);
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                llvm::Value *index = m_builder.CreateFPToUI(castValue(indexArg.second, indexArg.first), m_builder.getInt64Ty());
+                llvm::Value *itemPtr = m_builder.CreateCall(resolve_list_insert_empty(), { listPtr.ptr, index });
+                createInitialValueStore(valueArg.second, itemPtr, type);
+                // TODO: Implement list type prediction
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -980,6 +993,13 @@ void LLVMCodeBuilder::createListAppend(List *list)
     m_listPtrs[list] = LLVMListPtr();
 }
 
+void LLVMCodeBuilder::createListInsert(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::InsertToList, Compiler::StaticType::Void, { Compiler::StaticType::Number, Compiler::StaticType::Unknown }, 2);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     LLVMInstruction ins(LLVMInstruction::Type::BeginIf);
@@ -1936,6 +1956,12 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_append_empty()
     return resolveFunction("list_append_empty", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_insert_empty()
+{
+    llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("list_insert_empty", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr, m_builder.getInt64Ty() }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
 {
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index c786d216..9124311b 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -65,6 +65,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createListClear(List *list) override;
         void createListRemove(List *list) override;
         void createListAppend(List *list) override;
+        void createListInsert(List *list) override;
 
         void beginIfStatement() override;
         void beginElseBranch() override;
@@ -141,6 +142,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_list_clear();
         llvm::FunctionCallee resolve_list_remove();
         llvm::FunctionCallee resolve_list_append_empty();
+        llvm::FunctionCallee resolve_list_insert_empty();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index cd6de717..2bcd8a76 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -45,6 +45,7 @@ struct LLVMInstruction
             ClearList,
             RemoveListItem,
             AppendToList,
+            InsertToList,
             Yield,
             BeginIf,
             BeginElse,
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index ecdbd8b1..c3a3af2d 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -2072,6 +2072,68 @@ TEST_F(LLVMCodeBuilderTest, AppendToList)
     ASSERT_EQ(localList->toString(), "true false hello world");
 }
 
+TEST_F(LLVMCodeBuilderTest, InsertToList)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    std::unordered_map<List *, std::string> strings;
+
+    auto globalList = std::make_shared<List>("", "");
+    stage.addList(globalList);
+
+    auto localList = std::make_shared<List>("", "");
+    sprite.addList(localList);
+
+    globalList->append(1);
+    globalList->append(2);
+    globalList->append(3);
+
+    localList->append("Lorem");
+    localList->append("ipsum");
+    localList->append("dolor");
+    localList->append("sit");
+    strings[localList.get()] = localList->toString();
+
+    createBuilder(&sprite, true);
+
+    m_builder->addConstValue(2);
+    m_builder->addConstValue(1);
+    m_builder->createListInsert(globalList.get());
+
+    m_builder->addConstValue(3);
+    m_builder->addConstValue("test");
+    m_builder->createListInsert(globalList.get());
+
+    m_builder->addConstValue(0);
+    m_builder->addConstValue(3);
+    m_builder->createListInsert(localList.get());
+
+    m_builder->createListClear(localList.get());
+
+    m_builder->addConstValue(0);
+    m_builder->addConstValue(true);
+    m_builder->createListInsert(localList.get());
+
+    m_builder->addConstValue(0);
+    m_builder->addConstValue(false);
+    m_builder->createListInsert(localList.get());
+
+    m_builder->addConstValue(1);
+    m_builder->addConstValue("hello world");
+    m_builder->createListInsert(localList.get());
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    code->run(ctx.get());
+
+    ASSERT_EQ(globalList->toString(), "1 2 1 test 3");
+    ASSERT_EQ(localList->toString(), "false hello world true");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
index ee59dbfa..23e706eb 100644
--- a/test/mocks/codebuildermock.h
+++ b/test/mocks/codebuildermock.h
@@ -49,6 +49,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, createListClear, (List *), (override));
         MOCK_METHOD(void, createListRemove, (List *), (override));
         MOCK_METHOD(void, createListAppend, (List *), (override));
+        MOCK_METHOD(void, createListInsert, (List *), (override));
 
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));

From 79c605f9083693ea80132a15b6f4f3c23a77d88e Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sun, 17 Nov 2024 11:13:23 +0100
Subject: [PATCH 16/40] Add list_get_item() function

---
 src/scratch/list_functions.cpp               |  5 +++++
 src/scratch/list_functions.h                 |  2 ++
 test/scratch_classes/list_functions_test.cpp | 16 ++++++++++++++++
 3 files changed, 23 insertions(+)

diff --git a/src/scratch/list_functions.cpp b/src/scratch/list_functions.cpp
index 0fc46dc6..d7ed098d 100644
--- a/src/scratch/list_functions.cpp
+++ b/src/scratch/list_functions.cpp
@@ -27,4 +27,9 @@ extern "C"
     {
         return &list->insertEmpty(index);
     }
+
+    ValueData *list_get_item(List *list, size_t index)
+    {
+        return &list->operator[](index);
+    }
 }
diff --git a/src/scratch/list_functions.h b/src/scratch/list_functions.h
index f9e13924..ced8c216 100644
--- a/src/scratch/list_functions.h
+++ b/src/scratch/list_functions.h
@@ -17,6 +17,8 @@ extern "C"
 
     ValueData *list_append_empty(List *list);
     ValueData *list_insert_empty(List *list, size_t index);
+
+    ValueData *list_get_item(List *list, size_t index);
 }
 
 } // namespace libscratchcpp
diff --git a/test/scratch_classes/list_functions_test.cpp b/test/scratch_classes/list_functions_test.cpp
index 93340c75..5dafc6df 100644
--- a/test/scratch_classes/list_functions_test.cpp
+++ b/test/scratch_classes/list_functions_test.cpp
@@ -69,3 +69,19 @@ TEST(ListFunctionsTest, InsertEmpty)
     value_assign_string(v, "test");
     ASSERT_EQ(list.toString(), "5 Lorem test ipsum");
 }
+
+TEST(ListFunctionsTest, GetItem)
+{
+    List list("", "test list");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+
+    ASSERT_EQ(list_get_item(&list, 0), &list[0]);
+    ASSERT_EQ(list_get_item(&list, 1), &list[1]);
+    ASSERT_EQ(list_get_item(&list, 2), &list[2]);
+    ASSERT_EQ(list_get_item(&list, 3), &list[3]);
+    ASSERT_EQ(list_get_item(&list, 4), &list[4]);
+}

From aa1d055fb1bada24eca5c0af93157b87262a57f4 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Sun, 17 Nov 2024 11:13:46 +0100
Subject: [PATCH 17/40] LLVMCodeBuilder: Implement list replace

---
 src/dev/engine/internal/icodebuilder.h        |  1 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 26 +++++++++
 .../engine/internal/llvm/llvmcodebuilder.h    |  2 +
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        | 56 +++++++++++++++++++
 test/mocks/codebuildermock.h                  |  1 +
 6 files changed, 87 insertions(+)

diff --git a/src/dev/engine/internal/icodebuilder.h b/src/dev/engine/internal/icodebuilder.h
index 77641a01..492aaeeb 100644
--- a/src/dev/engine/internal/icodebuilder.h
+++ b/src/dev/engine/internal/icodebuilder.h
@@ -60,6 +60,7 @@ class ICodeBuilder
         virtual void createListRemove(List *list) = 0;
         virtual void createListAppend(List *list) = 0;
         virtual void createListInsert(List *list) = 0;
+        virtual void createListReplace(List *list) = 0;
 
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 901104fa..8d3f1708 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -517,6 +517,19 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::ListReplace: {
+                assert(step.args.size() == 2);
+                const auto &indexArg = step.args[0];
+                const auto &valueArg = step.args[1];
+                Compiler::StaticType type = optimizeRegisterType(valueArg.second);
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                llvm::Value *index = m_builder.CreateFPToUI(castValue(indexArg.second, indexArg.first), m_builder.getInt64Ty());
+                llvm::Value *itemPtr = m_builder.CreateCall(resolve_list_get_item(), { listPtr.ptr, index });
+                createValueStore(valueArg.second, itemPtr, type, listPtr.type);
+                // TODO: Implement list type prediction
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -1000,6 +1013,13 @@ void LLVMCodeBuilder::createListInsert(List *list)
     m_listPtrs[list] = LLVMListPtr();
 }
 
+void LLVMCodeBuilder::createListReplace(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::ListReplace, Compiler::StaticType::Void, { Compiler::StaticType::Number, Compiler::StaticType::Unknown }, 2);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     LLVMInstruction ins(LLVMInstruction::Type::BeginIf);
@@ -1962,6 +1982,12 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_insert_empty()
     return resolveFunction("list_insert_empty", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr, m_builder.getInt64Ty() }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_get_item()
+{
+    llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("list_get_item", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr, m_builder.getInt64Ty() }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
 {
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index 9124311b..1a71d4ae 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -66,6 +66,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createListRemove(List *list) override;
         void createListAppend(List *list) override;
         void createListInsert(List *list) override;
+        void createListReplace(List *list) override;
 
         void beginIfStatement() override;
         void beginElseBranch() override;
@@ -143,6 +144,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_list_remove();
         llvm::FunctionCallee resolve_list_append_empty();
         llvm::FunctionCallee resolve_list_insert_empty();
+        llvm::FunctionCallee resolve_list_get_item();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index 2bcd8a76..f57c9571 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -46,6 +46,7 @@ struct LLVMInstruction
             RemoveListItem,
             AppendToList,
             InsertToList,
+            ListReplace,
             Yield,
             BeginIf,
             BeginElse,
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index c3a3af2d..21cc350b 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -2134,6 +2134,62 @@ TEST_F(LLVMCodeBuilderTest, InsertToList)
     ASSERT_EQ(localList->toString(), "false hello world true");
 }
 
+TEST_F(LLVMCodeBuilderTest, ListReplace)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    std::unordered_map<List *, std::string> strings;
+
+    auto globalList = std::make_shared<List>("", "");
+    stage.addList(globalList);
+
+    auto localList = std::make_shared<List>("", "");
+    sprite.addList(localList);
+
+    globalList->append(1);
+    globalList->append(2);
+    globalList->append(3);
+
+    localList->append("Lorem");
+    localList->append("ipsum");
+    localList->append("dolor");
+    localList->append("sit");
+    strings[localList.get()] = localList->toString();
+
+    createBuilder(&sprite, true);
+
+    m_builder->addConstValue(2);
+    m_builder->addConstValue(1);
+    m_builder->createListReplace(globalList.get());
+
+    m_builder->addConstValue(1);
+    m_builder->addConstValue("test");
+    m_builder->createListReplace(globalList.get());
+
+    m_builder->addConstValue(0);
+    m_builder->addConstValue(3);
+    m_builder->createListReplace(localList.get());
+
+    m_builder->addConstValue(2);
+    m_builder->addConstValue(true);
+    m_builder->createListReplace(localList.get());
+
+    m_builder->addConstValue(3);
+    m_builder->addConstValue("hello world");
+    m_builder->createListReplace(localList.get());
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    code->run(ctx.get());
+
+    ASSERT_EQ(globalList->toString(), "1 test 1");
+    ASSERT_EQ(localList->toString(), "3 ipsum true hello world");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
index 23e706eb..8bd55c33 100644
--- a/test/mocks/codebuildermock.h
+++ b/test/mocks/codebuildermock.h
@@ -50,6 +50,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, createListRemove, (List *), (override));
         MOCK_METHOD(void, createListAppend, (List *), (override));
         MOCK_METHOD(void, createListInsert, (List *), (override));
+        MOCK_METHOD(void, createListReplace, (List *), (override));
 
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));

From d60cbe743dec841b8d05501d568a8f0a95ac7199 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Mon, 18 Nov 2024 14:50:17 +0100
Subject: [PATCH 18/40] LLVMCodeBuilder: Implement get list item

---
 src/dev/engine/internal/icodebuilder.h        |  1 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 30 ++++++++
 .../engine/internal/llvm/llvmcodebuilder.h    |  1 +
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        | 69 +++++++++++++++++++
 test/mocks/codebuildermock.h                  |  1 +
 6 files changed, 103 insertions(+)

diff --git a/src/dev/engine/internal/icodebuilder.h b/src/dev/engine/internal/icodebuilder.h
index 492aaeeb..45cf48c1 100644
--- a/src/dev/engine/internal/icodebuilder.h
+++ b/src/dev/engine/internal/icodebuilder.h
@@ -23,6 +23,7 @@ class ICodeBuilder
         virtual void addConstValue(const Value &value) = 0;
         virtual void addVariableValue(Variable *variable) = 0;
         virtual void addListContents(List *list) = 0;
+        virtual void addListItem(List *list) = 0;
 
         virtual void createAdd() = 0;
         virtual void createSub() = 0;
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 8d3f1708..bd2c59de 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -530,6 +530,16 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::GetListItem: {
+                assert(step.args.size() == 1);
+                const auto &arg = step.args[0];
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                llvm::Value *index = m_builder.CreateFPToUI(castValue(arg.second, arg.first), m_builder.getInt64Ty());
+                step.functionReturnReg->value = m_builder.CreateCall(resolve_list_get_item(), { listPtr.ptr, index });
+                step.functionReturnReg->type = listPtr.type;
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -848,6 +858,26 @@ void LLVMCodeBuilder::addListContents(List *list)
 {
 }
 
+void LLVMCodeBuilder::addListItem(List *list)
+{
+    LLVMInstruction ins(LLVMInstruction::Type::GetListItem);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+
+    assert(m_tmpRegs.size() >= 1);
+    ins.args.push_back({ Compiler::StaticType::Number, m_tmpRegs[0] });
+
+    m_tmpRegs.erase(m_tmpRegs.end() - 1, m_tmpRegs.end());
+
+    auto ret = std::make_shared<LLVMRegister>(Compiler::StaticType::Unknown);
+    ret->isRawValue = false;
+    ins.functionReturnReg = ret;
+    m_regs[m_currentFunction].push_back(ret);
+    m_tmpRegs.push_back(ret);
+
+    m_instructions.push_back(ins);
+}
+
 void LLVMCodeBuilder::createAdd()
 {
     createOp(LLVMInstruction::Type::Add, Compiler::StaticType::Number, Compiler::StaticType::Number, 2);
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index 1a71d4ae..7e20afeb 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -29,6 +29,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void addConstValue(const Value &value) override;
         void addVariableValue(Variable *variable) override;
         void addListContents(List *list) override;
+        void addListItem(List *list) override;
 
         void createAdd() override;
         void createSub() override;
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index f57c9571..c6547db3 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -47,6 +47,7 @@ struct LLVMInstruction
             AppendToList,
             InsertToList,
             ListReplace,
+            GetListItem,
             Yield,
             BeginIf,
             BeginElse,
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index 21cc350b..3320b733 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -2190,6 +2190,75 @@ TEST_F(LLVMCodeBuilderTest, ListReplace)
     ASSERT_EQ(localList->toString(), "3 ipsum true hello world");
 }
 
+TEST_F(LLVMCodeBuilderTest, GetListItem)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    std::unordered_map<List *, std::string> strings;
+
+    auto globalList = std::make_shared<List>("", "");
+    stage.addList(globalList);
+
+    auto localList = std::make_shared<List>("", "");
+    sprite.addList(localList);
+
+    globalList->append(1);
+    globalList->append(2);
+    globalList->append(3);
+
+    localList->append("Lorem");
+    localList->append("ipsum");
+    localList->append("dolor");
+    localList->append("sit");
+    strings[localList.get()] = localList->toString();
+
+    createBuilder(&sprite, true);
+
+    m_builder->addConstValue(2);
+    m_builder->addListItem(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(1);
+    m_builder->addConstValue("test");
+    m_builder->createListReplace(globalList.get());
+
+    m_builder->addConstValue(0);
+    m_builder->addListItem(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(0);
+    m_builder->addListItem(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(2);
+    m_builder->addListItem(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(3);
+    m_builder->addListItem(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    static const std::string expected =
+        "3\n"
+        "1\n"
+        "Lorem\n"
+        "dolor\n"
+        "sit\n";
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    testing::internal::CaptureStdout();
+    code->run(ctx.get());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
+
+    ASSERT_EQ(globalList->toString(), "1 test 3");
+    ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
index 8bd55c33..61f1c497 100644
--- a/test/mocks/codebuildermock.h
+++ b/test/mocks/codebuildermock.h
@@ -13,6 +13,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, addConstValue, (const Value &), (override));
         MOCK_METHOD(void, addVariableValue, (Variable *), (override));
         MOCK_METHOD(void, addListContents, (List *), (override));
+        MOCK_METHOD(void, addListItem, (List *), (override));
 
         MOCK_METHOD(void, createAdd, (), (override));
         MOCK_METHOD(void, createSub, (), (override));

From 116121b9bbc75e85922ab95c46247807cf5805aa Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Mon, 18 Nov 2024 20:30:27 +0100
Subject: [PATCH 19/40] Add list_size() function

---
 src/scratch/list_functions.cpp               |  5 +++++
 src/scratch/list_functions.h                 |  1 +
 test/scratch_classes/list_functions_test.cpp | 22 ++++++++++++++++++++
 3 files changed, 28 insertions(+)

diff --git a/src/scratch/list_functions.cpp b/src/scratch/list_functions.cpp
index d7ed098d..a8707c72 100644
--- a/src/scratch/list_functions.cpp
+++ b/src/scratch/list_functions.cpp
@@ -32,4 +32,9 @@ extern "C"
     {
         return &list->operator[](index);
     }
+
+    size_t list_size(List *list)
+    {
+        return list->size();
+    }
 }
diff --git a/src/scratch/list_functions.h b/src/scratch/list_functions.h
index ced8c216..52fd17d8 100644
--- a/src/scratch/list_functions.h
+++ b/src/scratch/list_functions.h
@@ -19,6 +19,7 @@ extern "C"
     ValueData *list_insert_empty(List *list, size_t index);
 
     ValueData *list_get_item(List *list, size_t index);
+    size_t list_size(List *list);
 }
 
 } // namespace libscratchcpp
diff --git a/test/scratch_classes/list_functions_test.cpp b/test/scratch_classes/list_functions_test.cpp
index 5dafc6df..09571bbc 100644
--- a/test/scratch_classes/list_functions_test.cpp
+++ b/test/scratch_classes/list_functions_test.cpp
@@ -85,3 +85,25 @@ TEST(ListFunctionsTest, GetItem)
     ASSERT_EQ(list_get_item(&list, 3), &list[3]);
     ASSERT_EQ(list_get_item(&list, 4), &list[4]);
 }
+
+TEST(ListFunctionsTest, Size)
+{
+    {
+        List list("", "");
+        list.append("Lorem");
+        list.append("ipsum");
+        list.append("dolor");
+        list.append("sit");
+        list.append("amet");
+
+        ASSERT_EQ(list_size(&list), 5);
+    }
+
+    {
+        List list("", "");
+        list.append("1");
+        list.append("2");
+
+        ASSERT_EQ(list_size(&list), 2);
+    }
+}

From ae122fc1ef86174bfe4126b633baa4377486948c Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Mon, 18 Nov 2024 21:57:26 +0100
Subject: [PATCH 20/40] LLVMCodeBuilder: Implement list size

---
 src/dev/engine/internal/icodebuilder.h        |  1 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 20 +++++++++
 .../engine/internal/llvm/llvmcodebuilder.h    |  2 +
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        | 45 +++++++++++++++++++
 test/mocks/codebuildermock.h                  |  1 +
 6 files changed, 70 insertions(+)

diff --git a/src/dev/engine/internal/icodebuilder.h b/src/dev/engine/internal/icodebuilder.h
index 45cf48c1..8d499c8f 100644
--- a/src/dev/engine/internal/icodebuilder.h
+++ b/src/dev/engine/internal/icodebuilder.h
@@ -24,6 +24,7 @@ class ICodeBuilder
         virtual void addVariableValue(Variable *variable) = 0;
         virtual void addListContents(List *list) = 0;
         virtual void addListItem(List *list) = 0;
+        virtual void addListSize(List *list) = 0;
 
         virtual void createAdd() = 0;
         virtual void createSub() = 0;
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index bd2c59de..bbd7a05c 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -540,6 +540,13 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::GetListSize: {
+                assert(step.args.size() == 0);
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                step.functionReturnReg->value = m_builder.CreateUIToFP(m_builder.CreateCall(resolve_list_size(), listPtr.ptr), m_builder.getDoubleTy());
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -878,6 +885,13 @@ void LLVMCodeBuilder::addListItem(List *list)
     m_instructions.push_back(ins);
 }
 
+void LLVMCodeBuilder::addListSize(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::GetListSize, Compiler::StaticType::Number, {}, 0);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::createAdd()
 {
     createOp(LLVMInstruction::Type::Add, Compiler::StaticType::Number, Compiler::StaticType::Number, 2);
@@ -2018,6 +2032,12 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_get_item()
     return resolveFunction("list_get_item", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr, m_builder.getInt64Ty() }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_size()
+{
+    llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("list_size", llvm::FunctionType::get(m_builder.getInt64Ty(), { listPtr }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
 {
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index 7e20afeb..2fbe38d1 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -30,6 +30,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void addVariableValue(Variable *variable) override;
         void addListContents(List *list) override;
         void addListItem(List *list) override;
+        void addListSize(List *list) override;
 
         void createAdd() override;
         void createSub() override;
@@ -146,6 +147,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_list_append_empty();
         llvm::FunctionCallee resolve_list_insert_empty();
         llvm::FunctionCallee resolve_list_get_item();
+        llvm::FunctionCallee resolve_list_size();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index c6547db3..70bf7776 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -48,6 +48,7 @@ struct LLVMInstruction
             InsertToList,
             ListReplace,
             GetListItem,
+            GetListSize,
             Yield,
             BeginIf,
             BeginElse,
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index 3320b733..b582f324 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -2259,6 +2259,51 @@ TEST_F(LLVMCodeBuilderTest, GetListItem)
     ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit");
 }
 
+TEST_F(LLVMCodeBuilderTest, GetListSize)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    auto globalList = std::make_shared<List>("", "");
+    stage.addList(globalList);
+
+    auto localList = std::make_shared<List>("", "");
+    sprite.addList(localList);
+
+    globalList->append(1);
+    globalList->append(2);
+    globalList->append(3);
+
+    localList->append("Lorem");
+    localList->append("ipsum");
+    localList->append("dolor");
+    localList->append("sit");
+
+    createBuilder(&sprite, true);
+
+    m_builder->addListSize(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addListSize(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    static const std::string expected =
+        "3\n"
+        "4\n";
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    testing::internal::CaptureStdout();
+    code->run(ctx.get());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
+
+    ASSERT_EQ(globalList->toString(), "123");
+    ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
index 61f1c497..9d312010 100644
--- a/test/mocks/codebuildermock.h
+++ b/test/mocks/codebuildermock.h
@@ -14,6 +14,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, addVariableValue, (Variable *), (override));
         MOCK_METHOD(void, addListContents, (List *), (override));
         MOCK_METHOD(void, addListItem, (List *), (override));
+        MOCK_METHOD(void, addListSize, (List *), (override));
 
         MOCK_METHOD(void, createAdd, (), (override));
         MOCK_METHOD(void, createSub, (), (override));

From 1b2a68e6942396b23aac0d3ea660123f0f083f29 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 17:27:27 +0100
Subject: [PATCH 21/40] List: Add data() method

---
 include/scratchcpp/list.h          |  3 +++
 test/scratch_classes/list_test.cpp | 17 +++++++++++++++++
 2 files changed, 20 insertions(+)

diff --git a/include/scratchcpp/list.h b/include/scratchcpp/list.h
index 715d093c..ff8d06e2 100644
--- a/include/scratchcpp/list.h
+++ b/include/scratchcpp/list.h
@@ -37,6 +37,9 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
         Monitor *monitor() const;
         void setMonitor(Monitor *monitor);
 
+        /*! Returns a pointer to the raw list data. */
+        inline ValueData *data() const { return m_dataPtr->data(); }
+
         /*! Returns the list size. */
         inline size_t size() const { return m_size; }
 
diff --git a/test/scratch_classes/list_test.cpp b/test/scratch_classes/list_test.cpp
index a6574b5d..458eebf9 100644
--- a/test/scratch_classes/list_test.cpp
+++ b/test/scratch_classes/list_test.cpp
@@ -40,6 +40,23 @@ TEST(ListTest, Monitor)
     ASSERT_EQ(list.monitor(), &monitor);
 }
 
+TEST(ListTest, Data)
+{
+    List list("", "");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+
+    ValueData *data = list.data();
+    ASSERT_EQ(&data[0], &list[0]);
+    ASSERT_EQ(&data[1], &list[1]);
+    ASSERT_EQ(&data[2], &list[2]);
+    ASSERT_EQ(&data[3], &list[3]);
+    ASSERT_EQ(&data[4], &list[4]);
+}
+
 TEST(ListTest, Size)
 {
     List list("", "test list");

From cd86c359a11979e32e13c9578fa9ffde818ed0ef Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 17:28:20 +0100
Subject: [PATCH 22/40] Add list_data() function

---
 src/scratch/list_functions.cpp               |  5 +++++
 src/scratch/list_functions.h                 |  1 +
 test/scratch_classes/list_functions_test.cpp | 13 +++++++++++++
 3 files changed, 19 insertions(+)

diff --git a/src/scratch/list_functions.cpp b/src/scratch/list_functions.cpp
index a8707c72..4bdb58c1 100644
--- a/src/scratch/list_functions.cpp
+++ b/src/scratch/list_functions.cpp
@@ -33,6 +33,11 @@ extern "C"
         return &list->operator[](index);
     }
 
+    ValueData *list_data(List *list)
+    {
+        return list->data();
+    }
+
     size_t list_size(List *list)
     {
         return list->size();
diff --git a/src/scratch/list_functions.h b/src/scratch/list_functions.h
index 52fd17d8..876ac638 100644
--- a/src/scratch/list_functions.h
+++ b/src/scratch/list_functions.h
@@ -19,6 +19,7 @@ extern "C"
     ValueData *list_insert_empty(List *list, size_t index);
 
     ValueData *list_get_item(List *list, size_t index);
+    ValueData *list_data(List *list);
     size_t list_size(List *list);
 }
 
diff --git a/test/scratch_classes/list_functions_test.cpp b/test/scratch_classes/list_functions_test.cpp
index 09571bbc..bc7dfea8 100644
--- a/test/scratch_classes/list_functions_test.cpp
+++ b/test/scratch_classes/list_functions_test.cpp
@@ -86,6 +86,19 @@ TEST(ListFunctionsTest, GetItem)
     ASSERT_EQ(list_get_item(&list, 4), &list[4]);
 }
 
+TEST(ListFunctionsTest, Data)
+{
+    List list("", "");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+
+    ValueData *data = list_data(&list);
+    ASSERT_EQ(data, list.data());
+}
+
 TEST(ListFunctionsTest, Size)
 {
     {

From 20d6b84e7a18b41d2aad7071e67637a989666e54 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 17:29:41 +0100
Subject: [PATCH 23/40] LLVMTypes: Add missing padding to ValueData struct

---
 src/dev/engine/internal/llvm/llvmtypes.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/dev/engine/internal/llvm/llvmtypes.cpp b/src/dev/engine/internal/llvm/llvmtypes.cpp
index bbd21f28..5dfc6075 100644
--- a/src/dev/engine/internal/llvm/llvmtypes.cpp
+++ b/src/dev/engine/internal/llvm/llvmtypes.cpp
@@ -14,10 +14,11 @@ llvm::StructType *LLVMTypes::createValueDataType(llvm::IRBuilder<> *builder)
     llvm::Type *unionType = builder->getInt64Ty(); // 64 bits is the largest size
 
     llvm::Type *valueType = llvm::Type::getInt32Ty(ctx); // Assuming ValueType is a 32-bit enum
+    llvm::Type *padding = llvm::Type::getInt32Ty(ctx);   // Padding for alignment
     llvm::Type *sizeType = llvm::Type::getInt64Ty(ctx);  // size_t
 
     llvm::StructType *ret = llvm::StructType::create(ctx, "ValueData");
-    ret->setBody({ unionType, valueType, sizeType });
+    ret->setBody({ unionType, valueType, padding, sizeType });
 
     return ret;
 }

From cc397a51492523456e47eb39c4bb367659f37895 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 17:32:29 +0100
Subject: [PATCH 24/40] LLVMCodeBuilder: Use data pointer to access list data

---
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 28 +++++++++++++++----
 .../engine/internal/llvm/llvmcodebuilder.h    |  4 ++-
 src/dev/engine/internal/llvm/llvmlistptr.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        |  4 +--
 4 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index bbd7a05c..7db3e7b1 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -96,8 +96,11 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     m_scopeVariables.push_back({});
 
     // Create list pointers
-    for (auto &[list, listPtr] : m_listPtrs)
+    for (auto &[list, listPtr] : m_listPtrs) {
         listPtr.ptr = getListPtr(targetLists, list);
+        listPtr.dataPtr = m_builder.CreateAlloca(m_valueDataType->getPointerTo());
+        m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
+    }
 
     // Execute recorded steps
     for (const LLVMInstruction &step : m_instructions) {
@@ -500,6 +503,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
                 llvm::Value *itemPtr = m_builder.CreateCall(resolve_list_append_empty(), listPtr.ptr);
                 createInitialValueStore(arg.second, itemPtr, type);
+                m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
                 // TODO: Implement list type prediction
                 break;
             }
@@ -513,6 +517,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 llvm::Value *index = m_builder.CreateFPToUI(castValue(indexArg.second, indexArg.first), m_builder.getInt64Ty());
                 llvm::Value *itemPtr = m_builder.CreateCall(resolve_list_insert_empty(), { listPtr.ptr, index });
                 createInitialValueStore(valueArg.second, itemPtr, type);
+                m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
                 // TODO: Implement list type prediction
                 break;
             }
@@ -524,7 +529,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 Compiler::StaticType type = optimizeRegisterType(valueArg.second);
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
                 llvm::Value *index = m_builder.CreateFPToUI(castValue(indexArg.second, indexArg.first), m_builder.getInt64Ty());
-                llvm::Value *itemPtr = m_builder.CreateCall(resolve_list_get_item(), { listPtr.ptr, index });
+                llvm::Value *itemPtr = getListItem(m_builder.CreateLoad(m_valueDataType->getPointerTo(), listPtr.dataPtr), index);
                 createValueStore(valueArg.second, itemPtr, type, listPtr.type);
                 // TODO: Implement list type prediction
                 break;
@@ -535,7 +540,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 const auto &arg = step.args[0];
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
                 llvm::Value *index = m_builder.CreateFPToUI(castValue(arg.second, arg.first), m_builder.getInt64Ty());
-                step.functionReturnReg->value = m_builder.CreateCall(resolve_list_get_item(), { listPtr.ptr, index });
+                step.functionReturnReg->value = getListItem(m_builder.CreateLoad(m_valueDataType->getPointerTo(), listPtr.dataPtr), index);
                 step.functionReturnReg->type = listPtr.type;
                 break;
             }
@@ -551,6 +556,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 if (!m_warp) {
                     freeHeap();
                     syncVariables(targetVariables);
+                    reloadLists();
                     coro->createSuspend();
                     reloadVariables(targetVariables);
                 }
@@ -1521,6 +1527,13 @@ void LLVMCodeBuilder::reloadVariables(llvm::Value *targetVariables)
     }
 }
 
+void LLVMCodeBuilder::reloadLists()
+{
+    // Reload list data pointers
+    for (auto &[list, listPtr] : m_listPtrs)
+        m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
+}
+
 LLVMInstruction &LLVMCodeBuilder::createOp(LLVMInstruction::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount)
 {
     std::vector<Compiler::StaticType> types;
@@ -1684,6 +1697,11 @@ void LLVMCodeBuilder::copyStructField(llvm::Value *source, llvm::Value *target,
     m_builder.CreateStore(m_builder.CreateLoad(fieldType, sourceField), targetField);
 }
 
+llvm::Value *LLVMCodeBuilder::getListItem(llvm::Value *dataPtr, llvm::Value *index)
+{
+    return m_builder.CreateGEP(m_valueDataType, dataPtr, index);
+}
+
 llvm::Value *LLVMCodeBuilder::createValue(LLVMRegisterPtr reg)
 {
     if (reg->isConstValue) {
@@ -2026,10 +2044,10 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_insert_empty()
     return resolveFunction("list_insert_empty", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr, m_builder.getInt64Ty() }, false));
 }
 
-llvm::FunctionCallee LLVMCodeBuilder::resolve_list_get_item()
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_data()
 {
     llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-    return resolveFunction("list_get_item", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr, m_builder.getInt64Ty() }, false));
+    return resolveFunction("list_data", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr }, false));
 }
 
 llvm::FunctionCallee LLVMCodeBuilder::resolve_list_size()
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index 2fbe38d1..6811d849 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -112,6 +112,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::Value *getListPtr(llvm::Value *targetLists, List *list);
         void syncVariables(llvm::Value *targetVariables);
         void reloadVariables(llvm::Value *targetVariables);
+        void reloadLists();
 
         LLVMInstruction &createOp(LLVMInstruction::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount);
         LLVMInstruction &createOp(LLVMInstruction::Type type, Compiler::StaticType retType, const std::vector<Compiler::StaticType> &argTypes, size_t argCount);
@@ -120,6 +121,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createInitialValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType);
         void createValueCopy(llvm::Value *source, llvm::Value *target);
         void copyStructField(llvm::Value *source, llvm::Value *target, int index, llvm::StructType *structType, llvm::Type *fieldType);
+        llvm::Value *getListItem(llvm::Value *dataPtr, llvm::Value *index);
         llvm::Value *createValue(LLVMRegisterPtr reg);
         llvm::Value *createComparison(LLVMRegisterPtr arg1, LLVMRegisterPtr arg2, Comparison type);
 
@@ -146,7 +148,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_list_remove();
         llvm::FunctionCallee resolve_list_append_empty();
         llvm::FunctionCallee resolve_list_insert_empty();
-        llvm::FunctionCallee resolve_list_get_item();
+        llvm::FunctionCallee resolve_list_data();
         llvm::FunctionCallee resolve_list_size();
         llvm::FunctionCallee resolve_strcasecmp();
 
diff --git a/src/dev/engine/internal/llvm/llvmlistptr.h b/src/dev/engine/internal/llvm/llvmlistptr.h
index 9dc93ec4..2df1ddf3 100644
--- a/src/dev/engine/internal/llvm/llvmlistptr.h
+++ b/src/dev/engine/internal/llvm/llvmlistptr.h
@@ -17,6 +17,7 @@ namespace libscratchcpp
 struct LLVMListPtr
 {
         llvm::Value *ptr = nullptr;
+        llvm::Value *dataPtr = nullptr;
         Compiler::StaticType type = Compiler::StaticType::Unknown;
 };
 
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index b582f324..a933298b 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -2134,7 +2134,7 @@ TEST_F(LLVMCodeBuilderTest, InsertToList)
     ASSERT_EQ(localList->toString(), "false hello world true");
 }
 
-TEST_F(LLVMCodeBuilderTest, ListReplace)
+/*TEST_F(LLVMCodeBuilderTest, ListReplace)
 {
     EngineMock engine;
     Stage stage;
@@ -2188,7 +2188,7 @@ TEST_F(LLVMCodeBuilderTest, ListReplace)
 
     ASSERT_EQ(globalList->toString(), "1 test 1");
     ASSERT_EQ(localList->toString(), "3 ipsum true hello world");
-}
+}*/
 
 TEST_F(LLVMCodeBuilderTest, GetListItem)
 {

From f9d1178b1b15fcf1aa1e9a60e78f8bac79c7740a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 17:32:58 +0100
Subject: [PATCH 25/40] Target: Free list data array

---
 src/scratch/target.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index aa555d74..d1e4224f 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -34,6 +34,9 @@ Target::~Target()
 {
     if (impl->variableData)
         free(impl->variableData);
+
+    if (impl->listData)
+        free(impl->listData);
 }
 
 /*! Returns true. */

From 8e559f1d54c0e2ffc5bed351dfe5d160ac0557b4 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 17:57:38 +0100
Subject: [PATCH 26/40] List: Add sizePtr() method

---
 include/scratchcpp/list.h          |  6 ++++++
 test/scratch_classes/list_test.cpp | 25 +++++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/include/scratchcpp/list.h b/include/scratchcpp/list.h
index ff8d06e2..192939bc 100644
--- a/include/scratchcpp/list.h
+++ b/include/scratchcpp/list.h
@@ -40,6 +40,12 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
         /*! Returns a pointer to the raw list data. */
         inline ValueData *data() const { return m_dataPtr->data(); }
 
+        /*!
+         * Returns a pointer to the list size.
+         * \note This is used internally by compiled code for various optimizations.
+         */
+        inline size_t *sizePtr() { return &m_size; }
+
         /*! Returns the list size. */
         inline size_t size() const { return m_size; }
 
diff --git a/test/scratch_classes/list_test.cpp b/test/scratch_classes/list_test.cpp
index 458eebf9..62263a41 100644
--- a/test/scratch_classes/list_test.cpp
+++ b/test/scratch_classes/list_test.cpp
@@ -57,6 +57,31 @@ TEST(ListTest, Data)
     ASSERT_EQ(&data[4], &list[4]);
 }
 
+TEST(ListTest, SizePtr)
+{
+    List list("", "test list");
+    ASSERT_TRUE(list.sizePtr());
+    ASSERT_EQ(*list.sizePtr(), 0);
+    ASSERT_TRUE(list.empty());
+
+    list.append("Lorem");
+    list.append("ipsum");
+    ASSERT_EQ(*list.sizePtr(), 2);
+    ASSERT_FALSE(list.empty());
+
+    list.append("dolor");
+    ASSERT_EQ(*list.sizePtr(), 3);
+    ASSERT_FALSE(list.empty());
+
+    list.removeAt(0);
+    ASSERT_EQ(*list.sizePtr(), 2);
+    ASSERT_FALSE(list.empty());
+
+    *list.sizePtr() = 100;
+    ASSERT_EQ(*list.sizePtr(), 100);
+    ASSERT_EQ(list.size(), 100);
+}
+
 TEST(ListTest, Size)
 {
     List list("", "test list");

From 06bb0b182e8c9b813992c0455e8f4d749facd1dd Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 18:00:10 +0100
Subject: [PATCH 27/40] Add list_size_ptr() function

---
 src/scratch/list_functions.cpp               |  5 +++++
 src/scratch/list_functions.h                 |  1 +
 test/scratch_classes/list_functions_test.cpp | 13 +++++++++++++
 3 files changed, 19 insertions(+)

diff --git a/src/scratch/list_functions.cpp b/src/scratch/list_functions.cpp
index 4bdb58c1..7b155f1b 100644
--- a/src/scratch/list_functions.cpp
+++ b/src/scratch/list_functions.cpp
@@ -42,4 +42,9 @@ extern "C"
     {
         return list->size();
     }
+
+    size_t *list_size_ptr(List *list)
+    {
+        return list->sizePtr();
+    }
 }
diff --git a/src/scratch/list_functions.h b/src/scratch/list_functions.h
index 876ac638..70f5b5d7 100644
--- a/src/scratch/list_functions.h
+++ b/src/scratch/list_functions.h
@@ -20,6 +20,7 @@ extern "C"
 
     ValueData *list_get_item(List *list, size_t index);
     ValueData *list_data(List *list);
+    size_t *list_size_ptr(List *list);
     size_t list_size(List *list);
 }
 
diff --git a/test/scratch_classes/list_functions_test.cpp b/test/scratch_classes/list_functions_test.cpp
index bc7dfea8..7fc158f6 100644
--- a/test/scratch_classes/list_functions_test.cpp
+++ b/test/scratch_classes/list_functions_test.cpp
@@ -99,6 +99,19 @@ TEST(ListFunctionsTest, Data)
     ASSERT_EQ(data, list.data());
 }
 
+TEST(ListFunctionsTest, SizePtr)
+{
+    List list("", "");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+
+    size_t *sizePtr = list_size_ptr(&list);
+    ASSERT_EQ(sizePtr, list.sizePtr());
+}
+
 TEST(ListFunctionsTest, Size)
 {
     {

From 19b76af010cf8f46d53d145f68fd0e50e8b9d078 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 18:00:42 +0100
Subject: [PATCH 28/40] LLVMCodeBuilder: Optimize list size

---
 src/dev/engine/internal/llvm/llvmcodebuilder.cpp | 9 ++++++---
 src/dev/engine/internal/llvm/llvmcodebuilder.h   | 2 +-
 src/dev/engine/internal/llvm/llvmlistptr.h       | 1 +
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 7db3e7b1..d7d42910 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -100,6 +100,8 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
         listPtr.ptr = getListPtr(targetLists, list);
         listPtr.dataPtr = m_builder.CreateAlloca(m_valueDataType->getPointerTo());
         m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
+        listPtr.sizePtr = m_builder.CreateAlloca(m_builder.getInt64Ty()->getPointerTo());
+        m_builder.CreateStore(m_builder.CreateCall(resolve_list_size_ptr(), listPtr.ptr), listPtr.sizePtr);
     }
 
     // Execute recorded steps
@@ -548,7 +550,8 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
             case LLVMInstruction::Type::GetListSize: {
                 assert(step.args.size() == 0);
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
-                step.functionReturnReg->value = m_builder.CreateUIToFP(m_builder.CreateCall(resolve_list_size(), listPtr.ptr), m_builder.getDoubleTy());
+                llvm::Value *sizePtr = m_builder.CreateLoad(m_builder.getInt64Ty()->getPointerTo(), listPtr.sizePtr);
+                step.functionReturnReg->value = m_builder.CreateUIToFP(m_builder.CreateLoad(m_builder.getInt64Ty(), sizePtr), m_builder.getDoubleTy());
                 break;
             }
 
@@ -2050,10 +2053,10 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_data()
     return resolveFunction("list_data", llvm::FunctionType::get(m_valueDataType->getPointerTo(), { listPtr }, false));
 }
 
-llvm::FunctionCallee LLVMCodeBuilder::resolve_list_size()
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_size_ptr()
 {
     llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-    return resolveFunction("list_size", llvm::FunctionType::get(m_builder.getInt64Ty(), { listPtr }, false));
+    return resolveFunction("list_size_ptr", llvm::FunctionType::get(m_builder.getInt64Ty()->getPointerTo()->getPointerTo(), { listPtr }, false));
 }
 
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index 6811d849..d84669ba 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -149,7 +149,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_list_append_empty();
         llvm::FunctionCallee resolve_list_insert_empty();
         llvm::FunctionCallee resolve_list_data();
-        llvm::FunctionCallee resolve_list_size();
+        llvm::FunctionCallee resolve_list_size_ptr();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
diff --git a/src/dev/engine/internal/llvm/llvmlistptr.h b/src/dev/engine/internal/llvm/llvmlistptr.h
index 2df1ddf3..e734664e 100644
--- a/src/dev/engine/internal/llvm/llvmlistptr.h
+++ b/src/dev/engine/internal/llvm/llvmlistptr.h
@@ -18,6 +18,7 @@ struct LLVMListPtr
 {
         llvm::Value *ptr = nullptr;
         llvm::Value *dataPtr = nullptr;
+        llvm::Value *sizePtr = nullptr;
         Compiler::StaticType type = Compiler::StaticType::Unknown;
 };
 

From 0ff30d023cd2f198968005c200b071730f3bc9d6 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 18:12:11 +0100
Subject: [PATCH 29/40] Add sizePtr() method to veque

---
 include/scratchcpp/veque.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/include/scratchcpp/veque.h b/include/scratchcpp/veque.h
index f75877c7..a994ebc6 100644
--- a/include/scratchcpp/veque.h
+++ b/include/scratchcpp/veque.h
@@ -375,6 +375,11 @@ namespace veque
             return _size;
         }
 
+        // For libscratchcpp List
+        inline const size_type *sizePtr() const noexcept {
+            return &_size;
+        }
+
         size_type max_size() const noexcept
         {
             constexpr auto compile_time_limit = std::min(

From 3a8bbb44e4c22728c8fdb4803bfe5a08929c31ef Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 21:21:03 +0100
Subject: [PATCH 30/40] List: Add allocatedSizePtr() method

---
 include/scratchcpp/list.h          |  6 ++++++
 test/scratch_classes/list_test.cpp | 17 +++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/include/scratchcpp/list.h b/include/scratchcpp/list.h
index 192939bc..ad85b3a3 100644
--- a/include/scratchcpp/list.h
+++ b/include/scratchcpp/list.h
@@ -46,6 +46,12 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
          */
         inline size_t *sizePtr() { return &m_size; }
 
+        /*!
+         * Returns a pointer to the allocated list size.
+         * \note This is used internally by compiled code for various optimizations.
+         */
+        inline const size_t *allocatedSizePtr() const { return m_dataPtr->sizePtr(); }
+
         /*! Returns the list size. */
         inline size_t size() const { return m_size; }
 
diff --git a/test/scratch_classes/list_test.cpp b/test/scratch_classes/list_test.cpp
index 62263a41..587996e8 100644
--- a/test/scratch_classes/list_test.cpp
+++ b/test/scratch_classes/list_test.cpp
@@ -62,6 +62,7 @@ TEST(ListTest, SizePtr)
     List list("", "test list");
     ASSERT_TRUE(list.sizePtr());
     ASSERT_EQ(*list.sizePtr(), 0);
+    const size_t *ptr = list.sizePtr();
     ASSERT_TRUE(list.empty());
 
     list.append("Lorem");
@@ -71,6 +72,7 @@ TEST(ListTest, SizePtr)
 
     list.append("dolor");
     ASSERT_EQ(*list.sizePtr(), 3);
+    ASSERT_EQ(list.sizePtr(), ptr);
     ASSERT_FALSE(list.empty());
 
     list.removeAt(0);
@@ -82,6 +84,21 @@ TEST(ListTest, SizePtr)
     ASSERT_EQ(list.size(), 100);
 }
 
+TEST(ListTest, AllocatedSizePtr)
+{
+    List list("", "test list");
+    ASSERT_TRUE(list.allocatedSizePtr());
+    ASSERT_EQ(*list.allocatedSizePtr(), 0);
+    const size_t *ptr = list.allocatedSizePtr();
+
+    list.append("Lorem");
+    list.append("ipsum");
+
+    ASSERT_GT(*list.allocatedSizePtr(), 0);
+    ASSERT_EQ(list.allocatedSizePtr(), ptr);
+    ASSERT_NE(list.allocatedSizePtr(), list.sizePtr());
+}
+
 TEST(ListTest, Size)
 {
     List list("", "test list");

From 2f2ed1453e6fb4472254609164eb49733e5fe2c1 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 21:21:33 +0100
Subject: [PATCH 31/40] Add list_alloc_size_ptr() function

---
 src/scratch/list_functions.cpp               | 13 +++++++++----
 src/scratch/list_functions.h                 |  1 +
 test/scratch_classes/list_functions_test.cpp | 13 +++++++++++++
 3 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/src/scratch/list_functions.cpp b/src/scratch/list_functions.cpp
index 7b155f1b..a10cb669 100644
--- a/src/scratch/list_functions.cpp
+++ b/src/scratch/list_functions.cpp
@@ -38,13 +38,18 @@ extern "C"
         return list->data();
     }
 
-    size_t list_size(List *list)
+    size_t *list_size_ptr(List *list)
     {
-        return list->size();
+        return list->sizePtr();
     }
 
-    size_t *list_size_ptr(List *list)
+    const size_t *list_alloc_size_ptr(List *list)
     {
-        return list->sizePtr();
+        return list->allocatedSizePtr();
+    }
+
+    size_t list_size(List *list)
+    {
+        return list->size();
     }
 }
diff --git a/src/scratch/list_functions.h b/src/scratch/list_functions.h
index 70f5b5d7..05edc4c4 100644
--- a/src/scratch/list_functions.h
+++ b/src/scratch/list_functions.h
@@ -21,6 +21,7 @@ extern "C"
     ValueData *list_get_item(List *list, size_t index);
     ValueData *list_data(List *list);
     size_t *list_size_ptr(List *list);
+    const size_t *list_alloc_size_ptr(List *list);
     size_t list_size(List *list);
 }
 
diff --git a/test/scratch_classes/list_functions_test.cpp b/test/scratch_classes/list_functions_test.cpp
index 7fc158f6..2f10e80f 100644
--- a/test/scratch_classes/list_functions_test.cpp
+++ b/test/scratch_classes/list_functions_test.cpp
@@ -112,6 +112,19 @@ TEST(ListFunctionsTest, SizePtr)
     ASSERT_EQ(sizePtr, list.sizePtr());
 }
 
+TEST(ListFunctionsTest, AllocSizePtr)
+{
+    List list("", "");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+
+    const size_t *sizePtr = list_alloc_size_ptr(&list);
+    ASSERT_EQ(sizePtr, list.allocatedSizePtr());
+}
+
 TEST(ListFunctionsTest, Size)
 {
     {

From 94fc6b17c9b29af5f7d5bae4d461de1ebb3f6090 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Tue, 19 Nov 2024 21:38:35 +0100
Subject: [PATCH 32/40] LLVMCodeBuilder: Do not use alloca for list size

---
 src/dev/engine/internal/llvm/llvmcodebuilder.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index d7d42910..3d1c67a8 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -100,8 +100,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
         listPtr.ptr = getListPtr(targetLists, list);
         listPtr.dataPtr = m_builder.CreateAlloca(m_valueDataType->getPointerTo());
         m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
-        listPtr.sizePtr = m_builder.CreateAlloca(m_builder.getInt64Ty()->getPointerTo());
-        m_builder.CreateStore(m_builder.CreateCall(resolve_list_size_ptr(), listPtr.ptr), listPtr.sizePtr);
+        listPtr.sizePtr = m_builder.CreateCall(resolve_list_size_ptr(), listPtr.ptr);
     }
 
     // Execute recorded steps
@@ -550,8 +549,8 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
             case LLVMInstruction::Type::GetListSize: {
                 assert(step.args.size() == 0);
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
-                llvm::Value *sizePtr = m_builder.CreateLoad(m_builder.getInt64Ty()->getPointerTo(), listPtr.sizePtr);
-                step.functionReturnReg->value = m_builder.CreateUIToFP(m_builder.CreateLoad(m_builder.getInt64Ty(), sizePtr), m_builder.getDoubleTy());
+                llvm::Value *size = m_builder.CreateLoad(m_builder.getInt64Ty(), listPtr.sizePtr);
+                step.functionReturnReg->value = m_builder.CreateUIToFP(size, m_builder.getDoubleTy());
                 break;
             }
 

From d429e0a27f45a68e55c77425512e2fefbfd7bfe2 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 20 Nov 2024 08:03:09 +0100
Subject: [PATCH 33/40] LLVMCodeBuilder: Optimize list append

---
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 34 ++++++++++++++++++-
 .../engine/internal/llvm/llvmcodebuilder.h    |  1 +
 src/dev/engine/internal/llvm/llvmlistptr.h    |  1 +
 3 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 3d1c67a8..c833da4d 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -98,9 +98,12 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     // Create list pointers
     for (auto &[list, listPtr] : m_listPtrs) {
         listPtr.ptr = getListPtr(targetLists, list);
+
         listPtr.dataPtr = m_builder.CreateAlloca(m_valueDataType->getPointerTo());
         m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
+
         listPtr.sizePtr = m_builder.CreateCall(resolve_list_size_ptr(), listPtr.ptr);
+        listPtr.allocatedSizePtr = m_builder.CreateCall(resolve_list_alloc_size_ptr(), listPtr.ptr);
     }
 
     // Execute recorded steps
@@ -502,9 +505,32 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 const auto &arg = step.args[0];
                 Compiler::StaticType type = optimizeRegisterType(arg.second);
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
-                llvm::Value *itemPtr = m_builder.CreateCall(resolve_list_append_empty(), listPtr.ptr);
+
+                // Check if enough space is allocated
+                llvm::Value *allocatedSize = m_builder.CreateLoad(m_builder.getInt64Ty(), listPtr.allocatedSizePtr);
+                llvm::Value *size = m_builder.CreateLoad(m_builder.getInt64Ty(), listPtr.sizePtr);
+                llvm::Value *isAllocated = m_builder.CreateICmpUGT(allocatedSize, size);
+                llvm::BasicBlock *ifBlock = llvm::BasicBlock::Create(m_ctx, "", func);
+                llvm::BasicBlock *elseBlock = llvm::BasicBlock::Create(m_ctx, "", func);
+                llvm::BasicBlock *nextBlock = llvm::BasicBlock::Create(m_ctx, "", func);
+                m_builder.CreateCondBr(isAllocated, ifBlock, elseBlock);
+
+                // If there's enough space, use the allocated memory
+                m_builder.SetInsertPoint(ifBlock);
+                llvm::Value *itemPtr = getListItem(m_builder.CreateLoad(m_valueDataType->getPointerTo(), listPtr.dataPtr), size);
+                createInitialValueStore(arg.second, itemPtr, type);
+                m_builder.CreateStore(m_builder.CreateAdd(size, m_builder.getInt64(1)), listPtr.sizePtr);
+                m_builder.CreateBr(nextBlock);
+
+                // Otherwise call appendEmpty()
+                m_builder.SetInsertPoint(elseBlock);
+                itemPtr = m_builder.CreateCall(resolve_list_append_empty(), listPtr.ptr);
                 createInitialValueStore(arg.second, itemPtr, type);
+                // TODO: Update list data only when needed
                 m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
+                m_builder.CreateBr(nextBlock);
+
+                m_builder.SetInsertPoint(nextBlock);
                 // TODO: Implement list type prediction
                 break;
             }
@@ -2058,6 +2084,12 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_size_ptr()
     return resolveFunction("list_size_ptr", llvm::FunctionType::get(m_builder.getInt64Ty()->getPointerTo()->getPointerTo(), { listPtr }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_alloc_size_ptr()
+{
+    llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("list_alloc_size_ptr", llvm::FunctionType::get(m_builder.getInt64Ty()->getPointerTo()->getPointerTo(), { listPtr }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
 {
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index d84669ba..c41cbe20 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -150,6 +150,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_list_insert_empty();
         llvm::FunctionCallee resolve_list_data();
         llvm::FunctionCallee resolve_list_size_ptr();
+        llvm::FunctionCallee resolve_list_alloc_size_ptr();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;
diff --git a/src/dev/engine/internal/llvm/llvmlistptr.h b/src/dev/engine/internal/llvm/llvmlistptr.h
index e734664e..c10ba9ea 100644
--- a/src/dev/engine/internal/llvm/llvmlistptr.h
+++ b/src/dev/engine/internal/llvm/llvmlistptr.h
@@ -19,6 +19,7 @@ struct LLVMListPtr
         llvm::Value *ptr = nullptr;
         llvm::Value *dataPtr = nullptr;
         llvm::Value *sizePtr = nullptr;
+        llvm::Value *allocatedSizePtr = nullptr;
         Compiler::StaticType type = Compiler::StaticType::Unknown;
 };
 

From f982aaed21b27fd9a17b17d70a0ed693e39f6c16 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Wed, 20 Nov 2024 09:36:00 +0100
Subject: [PATCH 34/40] LLVMCodeBuilder: Update list data pointer when needed

---
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 37 +++++++++++++++----
 .../engine/internal/llvm/llvmcodebuilder.h    |  3 +-
 src/dev/engine/internal/llvm/llvmlistptr.h    |  1 +
 3 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index c833da4d..649e9b57 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -104,6 +104,9 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
 
         listPtr.sizePtr = m_builder.CreateCall(resolve_list_size_ptr(), listPtr.ptr);
         listPtr.allocatedSizePtr = m_builder.CreateCall(resolve_list_alloc_size_ptr(), listPtr.ptr);
+
+        listPtr.dataPtrDirty = m_builder.CreateAlloca(m_builder.getInt1Ty());
+        m_builder.CreateStore(m_builder.getInt1(false), listPtr.dataPtrDirty);
     }
 
     // Execute recorded steps
@@ -488,6 +491,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 assert(step.args.size() == 0);
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
                 m_builder.CreateCall(resolve_list_clear(), listPtr.ptr);
+                // NOTE: Clearing doesn't deallocate (see List::clear()), so there's no need to update the data pointer
                 break;
             }
 
@@ -497,6 +501,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
                 llvm::Value *index = m_builder.CreateFPToUI(castValue(arg.second, arg.first), m_builder.getInt64Ty());
                 m_builder.CreateCall(resolve_list_remove(), { listPtr.ptr, index });
+                // NOTE: Removing doesn't deallocate (see List::removeAt()), so there's no need to update the data pointer
                 break;
             }
 
@@ -517,7 +522,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
 
                 // If there's enough space, use the allocated memory
                 m_builder.SetInsertPoint(ifBlock);
-                llvm::Value *itemPtr = getListItem(m_builder.CreateLoad(m_valueDataType->getPointerTo(), listPtr.dataPtr), size);
+                llvm::Value *itemPtr = getListItem(listPtr, size, func);
                 createInitialValueStore(arg.second, itemPtr, type);
                 m_builder.CreateStore(m_builder.CreateAdd(size, m_builder.getInt64(1)), listPtr.sizePtr);
                 m_builder.CreateBr(nextBlock);
@@ -526,8 +531,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 m_builder.SetInsertPoint(elseBlock);
                 itemPtr = m_builder.CreateCall(resolve_list_append_empty(), listPtr.ptr);
                 createInitialValueStore(arg.second, itemPtr, type);
-                // TODO: Update list data only when needed
-                m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
+                m_builder.CreateStore(m_builder.getInt1(true), listPtr.dataPtrDirty);
                 m_builder.CreateBr(nextBlock);
 
                 m_builder.SetInsertPoint(nextBlock);
@@ -541,10 +545,16 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 const auto &valueArg = step.args[1];
                 Compiler::StaticType type = optimizeRegisterType(valueArg.second);
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+
+                // dataPtrDirty
+                llvm::Value *allocatedSize = m_builder.CreateLoad(m_builder.getInt64Ty(), listPtr.allocatedSizePtr);
+                llvm::Value *size = m_builder.CreateLoad(m_builder.getInt64Ty(), listPtr.sizePtr);
+                m_builder.CreateStore(m_builder.CreateICmpEQ(allocatedSize, size), listPtr.dataPtrDirty);
+
+                // Insert
                 llvm::Value *index = m_builder.CreateFPToUI(castValue(indexArg.second, indexArg.first), m_builder.getInt64Ty());
                 llvm::Value *itemPtr = m_builder.CreateCall(resolve_list_insert_empty(), { listPtr.ptr, index });
                 createInitialValueStore(valueArg.second, itemPtr, type);
-                m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
                 // TODO: Implement list type prediction
                 break;
             }
@@ -556,7 +566,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 Compiler::StaticType type = optimizeRegisterType(valueArg.second);
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
                 llvm::Value *index = m_builder.CreateFPToUI(castValue(indexArg.second, indexArg.first), m_builder.getInt64Ty());
-                llvm::Value *itemPtr = getListItem(m_builder.CreateLoad(m_valueDataType->getPointerTo(), listPtr.dataPtr), index);
+                llvm::Value *itemPtr = getListItem(listPtr, index, func);
                 createValueStore(valueArg.second, itemPtr, type, listPtr.type);
                 // TODO: Implement list type prediction
                 break;
@@ -567,7 +577,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 const auto &arg = step.args[0];
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
                 llvm::Value *index = m_builder.CreateFPToUI(castValue(arg.second, arg.first), m_builder.getInt64Ty());
-                step.functionReturnReg->value = getListItem(m_builder.CreateLoad(m_valueDataType->getPointerTo(), listPtr.dataPtr), index);
+                step.functionReturnReg->value = getListItem(listPtr, index, func);
                 step.functionReturnReg->type = listPtr.type;
                 break;
             }
@@ -1562,6 +1572,16 @@ void LLVMCodeBuilder::reloadLists()
         m_builder.CreateStore(m_builder.CreateCall(resolve_list_data(), listPtr.ptr), listPtr.dataPtr);
 }
 
+void LLVMCodeBuilder::updateListDataPtr(const LLVMListPtr &listPtr, llvm::Function *func)
+{
+    // dataPtr = dirty ? list_data(list) : dataPtr
+    // dirty = false
+    llvm::Value *dirty = m_builder.CreateLoad(m_builder.getInt1Ty(), listPtr.dataPtrDirty);
+    llvm::Value *dataPtr = m_builder.CreateSelect(dirty, m_builder.CreateCall(resolve_list_data(), listPtr.ptr), m_builder.CreateLoad(m_valueDataType->getPointerTo(), listPtr.dataPtr));
+    m_builder.CreateStore(dataPtr, listPtr.dataPtr);
+    m_builder.CreateStore(m_builder.getInt1(false), listPtr.dataPtrDirty);
+}
+
 LLVMInstruction &LLVMCodeBuilder::createOp(LLVMInstruction::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount)
 {
     std::vector<Compiler::StaticType> types;
@@ -1725,9 +1745,10 @@ void LLVMCodeBuilder::copyStructField(llvm::Value *source, llvm::Value *target,
     m_builder.CreateStore(m_builder.CreateLoad(fieldType, sourceField), targetField);
 }
 
-llvm::Value *LLVMCodeBuilder::getListItem(llvm::Value *dataPtr, llvm::Value *index)
+llvm::Value *LLVMCodeBuilder::getListItem(const LLVMListPtr &listPtr, llvm::Value *index, llvm::Function *func)
 {
-    return m_builder.CreateGEP(m_valueDataType, dataPtr, index);
+    updateListDataPtr(listPtr, func);
+    return m_builder.CreateGEP(m_valueDataType, m_builder.CreateLoad(m_valueDataType->getPointerTo(), listPtr.dataPtr), index);
 }
 
 llvm::Value *LLVMCodeBuilder::createValue(LLVMRegisterPtr reg)
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index c41cbe20..a83affa9 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -113,6 +113,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void syncVariables(llvm::Value *targetVariables);
         void reloadVariables(llvm::Value *targetVariables);
         void reloadLists();
+        void updateListDataPtr(const LLVMListPtr &listPtr, llvm::Function *func);
 
         LLVMInstruction &createOp(LLVMInstruction::Type type, Compiler::StaticType retType, Compiler::StaticType argType, size_t argCount);
         LLVMInstruction &createOp(LLVMInstruction::Type type, Compiler::StaticType retType, const std::vector<Compiler::StaticType> &argTypes, size_t argCount);
@@ -121,7 +122,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createInitialValueStore(LLVMRegisterPtr reg, llvm::Value *targetPtr, Compiler::StaticType sourceType);
         void createValueCopy(llvm::Value *source, llvm::Value *target);
         void copyStructField(llvm::Value *source, llvm::Value *target, int index, llvm::StructType *structType, llvm::Type *fieldType);
-        llvm::Value *getListItem(llvm::Value *dataPtr, llvm::Value *index);
+        llvm::Value *getListItem(const LLVMListPtr &listPtr, llvm::Value *index, llvm::Function *func);
         llvm::Value *createValue(LLVMRegisterPtr reg);
         llvm::Value *createComparison(LLVMRegisterPtr arg1, LLVMRegisterPtr arg2, Comparison type);
 
diff --git a/src/dev/engine/internal/llvm/llvmlistptr.h b/src/dev/engine/internal/llvm/llvmlistptr.h
index c10ba9ea..6b427572 100644
--- a/src/dev/engine/internal/llvm/llvmlistptr.h
+++ b/src/dev/engine/internal/llvm/llvmlistptr.h
@@ -20,6 +20,7 @@ struct LLVMListPtr
         llvm::Value *dataPtr = nullptr;
         llvm::Value *sizePtr = nullptr;
         llvm::Value *allocatedSizePtr = nullptr;
+        llvm::Value *dataPtrDirty = nullptr;
         Compiler::StaticType type = Compiler::StaticType::Unknown;
 };
 

From e139e3ca83d23ecc495bc08885635ff35ee893a9 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 21 Nov 2024 14:18:30 +0100
Subject: [PATCH 35/40] LLVMCodeBuilder: Add missing ValueData padding

---
 src/dev/engine/internal/llvm/llvmcodebuilder.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 649e9b57..0b418d41 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -1735,7 +1735,8 @@ void LLVMCodeBuilder::createValueCopy(llvm::Value *source, llvm::Value *target)
     // NOTE: This doesn't copy strings, but only the pointers
     copyStructField(source, target, 0, m_valueDataType, m_builder.getInt64Ty()); // value
     copyStructField(source, target, 1, m_valueDataType, m_builder.getInt32Ty()); // type
-    copyStructField(source, target, 2, m_valueDataType, m_builder.getInt64Ty()); // string size
+    /* 2: padding */
+    copyStructField(source, target, 3, m_valueDataType, m_builder.getInt64Ty()); // string size
 }
 
 void LLVMCodeBuilder::copyStructField(llvm::Value *source, llvm::Value *target, int index, llvm::StructType *structType, llvm::Type *fieldType)
@@ -1764,7 +1765,8 @@ llvm::Value *LLVMCodeBuilder::createValue(LLVMRegisterPtr reg)
             value = llvm::ConstantExpr::getBitCast(value, m_valueDataType->getElementType(0));
 
         llvm::Constant *type = m_builder.getInt32(static_cast<uint32_t>(reg->constValue.type()));
-        llvm::Constant *constValue = llvm::ConstantStruct::get(m_valueDataType, { value, type, m_builder.getInt64(0) });
+        llvm::Constant *padding = m_builder.getInt32(0);
+        llvm::Constant *constValue = llvm::ConstantStruct::get(m_valueDataType, { value, type, padding, m_builder.getInt64(0) });
         m_builder.CreateStore(constValue, ret);
 
         return ret;

From b1319ed129a687dbb463122c877cf8ca457aa913 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 21 Nov 2024 14:23:04 +0100
Subject: [PATCH 36/40] LLVMCodeBuilder: Fix ValueData constants

---
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 22 +++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 0b418d41..647f88f5 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -1759,10 +1759,24 @@ llvm::Value *LLVMCodeBuilder::createValue(LLVMRegisterPtr reg)
         llvm::Constant *value = castConstValue(reg->constValue, TYPE_MAP[reg->constValue.type()]);
         llvm::Value *ret = m_builder.CreateAlloca(m_valueDataType);
 
-        if (reg->constValue.type() == ValueType::String)
-            value = llvm::ConstantExpr::getPtrToInt(value, m_valueDataType->getElementType(0));
-        else
-            value = llvm::ConstantExpr::getBitCast(value, m_valueDataType->getElementType(0));
+        switch (reg->constValue.type()) {
+            case ValueType::Number:
+                value = llvm::ConstantExpr::getBitCast(value, m_valueDataType->getElementType(0));
+                break;
+
+            case ValueType::Bool:
+                // Assuming union type is int64
+                value = m_builder.getInt64(reg->constValue.toBool());
+                break;
+
+            case ValueType::String:
+                value = llvm::ConstantExpr::getPtrToInt(value, m_valueDataType->getElementType(0));
+                break;
+
+            default:
+                assert(false);
+                break;
+        }
 
         llvm::Constant *type = m_builder.getInt32(static_cast<uint32_t>(reg->constValue.type()));
         llvm::Constant *padding = m_builder.getInt32(0);

From b05996c9dc18302e9735845dd02c45c2e2f50a9f Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 21 Nov 2024 14:24:02 +0100
Subject: [PATCH 37/40] LLVMCodeBuilder: Implement list item index

---
 src/dev/engine/internal/icodebuilder.h        |  1 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 65 +++++++++++++
 .../engine/internal/llvm/llvmcodebuilder.h    |  2 +
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        | 91 +++++++++++++++++++
 test/mocks/codebuildermock.h                  |  1 +
 6 files changed, 161 insertions(+)

diff --git a/src/dev/engine/internal/icodebuilder.h b/src/dev/engine/internal/icodebuilder.h
index 8d499c8f..4d602122 100644
--- a/src/dev/engine/internal/icodebuilder.h
+++ b/src/dev/engine/internal/icodebuilder.h
@@ -24,6 +24,7 @@ class ICodeBuilder
         virtual void addVariableValue(Variable *variable) = 0;
         virtual void addListContents(List *list) = 0;
         virtual void addListItem(List *list) = 0;
+        virtual void addListItemIndex(List *list) = 0;
         virtual void addListSize(List *list) = 0;
 
         virtual void createAdd() = 0;
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 647f88f5..8cc39abf 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -590,6 +590,14 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::GetListItemIndex: {
+                assert(step.args.size() == 1);
+                const auto &arg = step.args[0];
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                step.functionReturnReg->value = getListItemIndex(listPtr, arg.second, func);
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -929,6 +937,13 @@ void LLVMCodeBuilder::addListItem(List *list)
     m_instructions.push_back(ins);
 }
 
+void LLVMCodeBuilder::addListItemIndex(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::GetListItemIndex, Compiler::StaticType::Number, Compiler::StaticType::Unknown, 1);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::addListSize(List *list)
 {
     LLVMInstruction &ins = createOp(LLVMInstruction::Type::GetListSize, Compiler::StaticType::Number, {}, 0);
@@ -1752,6 +1767,56 @@ llvm::Value *LLVMCodeBuilder::getListItem(const LLVMListPtr &listPtr, llvm::Valu
     return m_builder.CreateGEP(m_valueDataType, m_builder.CreateLoad(m_valueDataType->getPointerTo(), listPtr.dataPtr), index);
 }
 
+llvm::Value *LLVMCodeBuilder::getListItemIndex(const LLVMListPtr &listPtr, LLVMRegisterPtr item, llvm::Function *func)
+{
+    llvm::Value *size = m_builder.CreateLoad(m_builder.getInt64Ty(), listPtr.sizePtr);
+    llvm::BasicBlock *condBlock = llvm::BasicBlock::Create(m_ctx, "", func);
+    llvm::BasicBlock *bodyBlock = llvm::BasicBlock::Create(m_ctx, "", func);
+    llvm::BasicBlock *cmpIfBlock = llvm::BasicBlock::Create(m_ctx, "", func);
+    llvm::BasicBlock *cmpElseBlock = llvm::BasicBlock::Create(m_ctx, "", func);
+    llvm::BasicBlock *notFoundBlock = llvm::BasicBlock::Create(m_ctx, "", func);
+    llvm::BasicBlock *nextBlock = llvm::BasicBlock::Create(m_ctx, "", func);
+
+    // index = 0
+    llvm::Value *index = m_builder.CreateAlloca(m_builder.getInt64Ty());
+    m_builder.CreateStore(m_builder.getInt64(0), index);
+    m_builder.CreateBr(condBlock);
+
+    // while (index < size)
+    m_builder.SetInsertPoint(condBlock);
+    llvm::Value *cond = m_builder.CreateICmpULT(m_builder.CreateLoad(m_builder.getInt64Ty(), index), size);
+    m_builder.CreateCondBr(cond, bodyBlock, notFoundBlock);
+
+    // if (list[index] == item)
+    m_builder.SetInsertPoint(bodyBlock);
+    LLVMRegisterPtr currentItem = std::make_shared<LLVMRegister>(listPtr.type);
+    currentItem->isRawValue = false;
+    currentItem->value = getListItem(listPtr, m_builder.CreateLoad(m_builder.getInt64Ty(), index), func);
+    llvm::Value *cmp = createComparison(currentItem, item, Comparison::EQ);
+    m_builder.CreateCondBr(cmp, cmpIfBlock, cmpElseBlock);
+
+    // goto nextBlock
+    m_builder.SetInsertPoint(cmpIfBlock);
+    m_builder.CreateBr(nextBlock);
+
+    // else index++
+    m_builder.SetInsertPoint(cmpElseBlock);
+    m_builder.CreateStore(m_builder.CreateAdd(m_builder.CreateLoad(m_builder.getInt64Ty(), index), m_builder.getInt64(1)), index);
+    m_builder.CreateBr(condBlock);
+
+    // notFoundBlock:
+    // index = -1
+    // goto nextBlock
+    m_builder.SetInsertPoint(notFoundBlock);
+    m_builder.CreateStore(llvm::ConstantInt::get(llvm::Type::getInt64Ty(m_ctx), -1, true), index);
+    m_builder.CreateBr(nextBlock);
+
+    // nextBlock:
+    m_builder.SetInsertPoint(nextBlock);
+
+    return m_builder.CreateSIToFP(m_builder.CreateLoad(m_builder.getInt64Ty(), index), m_builder.getDoubleTy());
+}
+
 llvm::Value *LLVMCodeBuilder::createValue(LLVMRegisterPtr reg)
 {
     if (reg->isConstValue) {
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index a83affa9..d00a585d 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -30,6 +30,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void addVariableValue(Variable *variable) override;
         void addListContents(List *list) override;
         void addListItem(List *list) override;
+        void addListItemIndex(List *list) override;
         void addListSize(List *list) override;
 
         void createAdd() override;
@@ -123,6 +124,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void createValueCopy(llvm::Value *source, llvm::Value *target);
         void copyStructField(llvm::Value *source, llvm::Value *target, int index, llvm::StructType *structType, llvm::Type *fieldType);
         llvm::Value *getListItem(const LLVMListPtr &listPtr, llvm::Value *index, llvm::Function *func);
+        llvm::Value *getListItemIndex(const LLVMListPtr &listPtr, LLVMRegisterPtr item, llvm::Function *func);
         llvm::Value *createValue(LLVMRegisterPtr reg);
         llvm::Value *createComparison(LLVMRegisterPtr arg1, LLVMRegisterPtr arg2, Comparison type);
 
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index 70bf7776..2aaedd13 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -49,6 +49,7 @@ struct LLVMInstruction
             ListReplace,
             GetListItem,
             GetListSize,
+            GetListItemIndex,
             Yield,
             BeginIf,
             BeginElse,
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index a933298b..3ba93ea6 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -2304,6 +2304,97 @@ TEST_F(LLVMCodeBuilderTest, GetListSize)
     ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit");
 }
 
+TEST_F(LLVMCodeBuilderTest, GetListItemIndex)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    auto globalList = std::make_shared<List>("", "");
+    stage.addList(globalList);
+
+    auto localList = std::make_shared<List>("", "");
+    sprite.addList(localList);
+
+    globalList->append(1);
+    globalList->append(2);
+    globalList->append(3);
+
+    localList->append("Lorem");
+    localList->append("ipsum");
+    localList->append("dolor");
+    localList->append("sit");
+
+    createBuilder(&sprite, true);
+
+    m_builder->addConstValue(2);
+    m_builder->addListItemIndex(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(1);
+    m_builder->addListItemIndex(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(0);
+    m_builder->addListItemIndex(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(1);
+    m_builder->addConstValue("test");
+    m_builder->createListReplace(globalList.get());
+
+    m_builder->addConstValue(2);
+    m_builder->addListItemIndex(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(1);
+    m_builder->addListItemIndex(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue("test");
+    m_builder->addListItemIndex(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue("abc");
+    m_builder->addListItemIndex(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue("doLor");
+    m_builder->addListItemIndex(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(true);
+    m_builder->addListItemIndex(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue("site");
+    m_builder->addListItemIndex(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    static const std::string expected =
+        "1\n"
+        "0\n"
+        "-1\n"
+        "-1\n"
+        "0\n"
+        "1\n"
+        "-1\n"
+        "2\n"
+        "-1\n"
+        "-1\n";
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    testing::internal::CaptureStdout();
+    code->run(ctx.get());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
+
+    ASSERT_EQ(globalList->toString(), "1 test 3");
+    ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
index 9d312010..1903807f 100644
--- a/test/mocks/codebuildermock.h
+++ b/test/mocks/codebuildermock.h
@@ -14,6 +14,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, addVariableValue, (Variable *), (override));
         MOCK_METHOD(void, addListContents, (List *), (override));
         MOCK_METHOD(void, addListItem, (List *), (override));
+        MOCK_METHOD(void, addListItemIndex, (List *), (override));
         MOCK_METHOD(void, addListSize, (List *), (override));
 
         MOCK_METHOD(void, createAdd, (), (override));

From c40db7fe482fcd200d8354283749b84aafad6a67 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 21 Nov 2024 14:31:19 +0100
Subject: [PATCH 38/40] LLVMCodeBuilder: Uncomment list replace test

---
 test/dev/llvm/llvmcodebuilder_test.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index 3ba93ea6..b22d39b3 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -2134,7 +2134,7 @@ TEST_F(LLVMCodeBuilderTest, InsertToList)
     ASSERT_EQ(localList->toString(), "false hello world true");
 }
 
-/*TEST_F(LLVMCodeBuilderTest, ListReplace)
+TEST_F(LLVMCodeBuilderTest, ListReplace)
 {
     EngineMock engine;
     Stage stage;
@@ -2188,7 +2188,7 @@ TEST_F(LLVMCodeBuilderTest, InsertToList)
 
     ASSERT_EQ(globalList->toString(), "1 test 1");
     ASSERT_EQ(localList->toString(), "3 ipsum true hello world");
-}*/
+}
 
 TEST_F(LLVMCodeBuilderTest, GetListItem)
 {

From b0d26666df25fbca2accc0b217f9005c88d43d53 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 21 Nov 2024 14:32:50 +0100
Subject: [PATCH 39/40] LLVMCodeBuilder: Implement list contains

---
 src/dev/engine/internal/icodebuilder.h        |  1 +
 .../engine/internal/llvm/llvmcodebuilder.cpp  | 20 +++-
 .../engine/internal/llvm/llvmcodebuilder.h    |  1 +
 .../engine/internal/llvm/llvminstruction.h    |  1 +
 test/dev/llvm/llvmcodebuilder_test.cpp        | 91 +++++++++++++++++++
 test/mocks/codebuildermock.h                  |  1 +
 6 files changed, 113 insertions(+), 2 deletions(-)

diff --git a/src/dev/engine/internal/icodebuilder.h b/src/dev/engine/internal/icodebuilder.h
index 4d602122..30d60cfe 100644
--- a/src/dev/engine/internal/icodebuilder.h
+++ b/src/dev/engine/internal/icodebuilder.h
@@ -25,6 +25,7 @@ class ICodeBuilder
         virtual void addListContents(List *list) = 0;
         virtual void addListItem(List *list) = 0;
         virtual void addListItemIndex(List *list) = 0;
+        virtual void addListContains(List *list) = 0;
         virtual void addListSize(List *list) = 0;
 
         virtual void createAdd() = 0;
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
index 8cc39abf..cd791169 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.cpp
@@ -594,7 +594,16 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 assert(step.args.size() == 1);
                 const auto &arg = step.args[0];
                 const LLVMListPtr &listPtr = m_listPtrs[step.workList];
-                step.functionReturnReg->value = getListItemIndex(listPtr, arg.second, func);
+                step.functionReturnReg->value = m_builder.CreateSIToFP(getListItemIndex(listPtr, arg.second, func), m_builder.getDoubleTy());
+                break;
+            }
+
+            case LLVMInstruction::Type::ListContainsItem: {
+                assert(step.args.size() == 1);
+                const auto &arg = step.args[0];
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                llvm::Value *index = getListItemIndex(listPtr, arg.second, func);
+                step.functionReturnReg->value = m_builder.CreateICmpSGT(index, llvm::ConstantInt::get(m_builder.getInt64Ty(), -1, true));
                 break;
             }
 
@@ -944,6 +953,13 @@ void LLVMCodeBuilder::addListItemIndex(List *list)
     m_listPtrs[list] = LLVMListPtr();
 }
 
+void LLVMCodeBuilder::addListContains(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::ListContainsItem, Compiler::StaticType::Bool, Compiler::StaticType::Unknown, 1);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::addListSize(List *list)
 {
     LLVMInstruction &ins = createOp(LLVMInstruction::Type::GetListSize, Compiler::StaticType::Number, {}, 0);
@@ -1814,7 +1830,7 @@ llvm::Value *LLVMCodeBuilder::getListItemIndex(const LLVMListPtr &listPtr, LLVMR
     // nextBlock:
     m_builder.SetInsertPoint(nextBlock);
 
-    return m_builder.CreateSIToFP(m_builder.CreateLoad(m_builder.getInt64Ty(), index), m_builder.getDoubleTy());
+    return m_builder.CreateLoad(m_builder.getInt64Ty(), index);
 }
 
 llvm::Value *LLVMCodeBuilder::createValue(LLVMRegisterPtr reg)
diff --git a/src/dev/engine/internal/llvm/llvmcodebuilder.h b/src/dev/engine/internal/llvm/llvmcodebuilder.h
index d00a585d..ef52b110 100644
--- a/src/dev/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/dev/engine/internal/llvm/llvmcodebuilder.h
@@ -31,6 +31,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         void addListContents(List *list) override;
         void addListItem(List *list) override;
         void addListItemIndex(List *list) override;
+        void addListContains(List *list) override;
         void addListSize(List *list) override;
 
         void createAdd() override;
diff --git a/src/dev/engine/internal/llvm/llvminstruction.h b/src/dev/engine/internal/llvm/llvminstruction.h
index 2aaedd13..afc13d1d 100644
--- a/src/dev/engine/internal/llvm/llvminstruction.h
+++ b/src/dev/engine/internal/llvm/llvminstruction.h
@@ -50,6 +50,7 @@ struct LLVMInstruction
             GetListItem,
             GetListSize,
             GetListItemIndex,
+            ListContainsItem,
             Yield,
             BeginIf,
             BeginElse,
diff --git a/test/dev/llvm/llvmcodebuilder_test.cpp b/test/dev/llvm/llvmcodebuilder_test.cpp
index b22d39b3..268e5802 100644
--- a/test/dev/llvm/llvmcodebuilder_test.cpp
+++ b/test/dev/llvm/llvmcodebuilder_test.cpp
@@ -2395,6 +2395,97 @@ TEST_F(LLVMCodeBuilderTest, GetListItemIndex)
     ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit");
 }
 
+TEST_F(LLVMCodeBuilderTest, ListContainsItem)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    auto globalList = std::make_shared<List>("", "");
+    stage.addList(globalList);
+
+    auto localList = std::make_shared<List>("", "");
+    sprite.addList(localList);
+
+    globalList->append(1);
+    globalList->append(2);
+    globalList->append(3);
+
+    localList->append("Lorem");
+    localList->append("ipsum");
+    localList->append("dolor");
+    localList->append("sit");
+
+    createBuilder(&sprite, true);
+
+    m_builder->addConstValue(2);
+    m_builder->addListContains(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(1);
+    m_builder->addListContains(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(0);
+    m_builder->addListContains(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(1);
+    m_builder->addConstValue("test");
+    m_builder->createListReplace(globalList.get());
+
+    m_builder->addConstValue(2);
+    m_builder->addListContains(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(1);
+    m_builder->addListContains(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue("test");
+    m_builder->addListContains(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue("abc");
+    m_builder->addListContains(globalList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue("doLor");
+    m_builder->addListContains(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue(true);
+    m_builder->addListContains(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    m_builder->addConstValue("site");
+    m_builder->addListContains(localList.get());
+    m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+    static const std::string expected =
+        "true\n"
+        "true\n"
+        "false\n"
+        "false\n"
+        "true\n"
+        "true\n"
+        "false\n"
+        "true\n"
+        "false\n"
+        "false\n";
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    testing::internal::CaptureStdout();
+    code->run(ctx.get());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
+
+    ASSERT_EQ(globalList->toString(), "1 test 3");
+    ASSERT_EQ(localList->toString(), "Lorem ipsum dolor sit");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
index 1903807f..4aa0daeb 100644
--- a/test/mocks/codebuildermock.h
+++ b/test/mocks/codebuildermock.h
@@ -15,6 +15,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, addListContents, (List *), (override));
         MOCK_METHOD(void, addListItem, (List *), (override));
         MOCK_METHOD(void, addListItemIndex, (List *), (override));
+        MOCK_METHOD(void, addListContains, (List *), (override));
         MOCK_METHOD(void, addListSize, (List *), (override));
 
         MOCK_METHOD(void, createAdd, (), (override));

From d07178386c255da43bffc1068071cfff37880a8a Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Thu, 21 Nov 2024 16:25:57 +0100
Subject: [PATCH 40/40] Compiler: Add list methods

---
 include/scratchcpp/dev/compiler.h   | 10 +++++
 src/dev/engine/compiler.cpp         | 57 +++++++++++++++++++++++++
 test/dev/compiler/compiler_test.cpp | 64 +++++++++++++++++++++++++++++
 3 files changed, 131 insertions(+)

diff --git a/include/scratchcpp/dev/compiler.h b/include/scratchcpp/dev/compiler.h
index fa6550c8..b42f976d 100644
--- a/include/scratchcpp/dev/compiler.h
+++ b/include/scratchcpp/dev/compiler.h
@@ -46,6 +46,10 @@ class LIBSCRATCHCPP_EXPORT Compiler
         void addConstValue(const Value &value);
         void addVariableValue(Variable *variable);
         void addListContents(List *list);
+        void addListItem(List *list);
+        void addListItemIndex(List *list);
+        void addListContains(List *list);
+        void addListSize(List *list);
         void addInput(const std::string &name);
 
         void createAdd();
@@ -80,6 +84,12 @@ class LIBSCRATCHCPP_EXPORT Compiler
 
         void createVariableWrite(Variable *variable);
 
+        void createListClear(List *list);
+        void createListRemove(List *list);
+        void createListAppend(List *list);
+        void createListInsert(List *list);
+        void createListReplace(List *list);
+
         void beginIfStatement();
         void beginElseBranch();
         void endIf();
diff --git a/src/dev/engine/compiler.cpp b/src/dev/engine/compiler.cpp
index ed225ff2..c8f134fa 100644
--- a/src/dev/engine/compiler.cpp
+++ b/src/dev/engine/compiler.cpp
@@ -100,6 +100,30 @@ void Compiler::addListContents(List *list)
     impl->builder->addListContents(list);
 }
 
+/*! Adds the item with index from the last value of the given list to the code. */
+void Compiler::addListItem(List *list)
+{
+    impl->builder->addListItem(list);
+}
+
+/*! Adds the index of the item from the last value of the given list to the code. */
+void Compiler::addListItemIndex(List *list)
+{
+    impl->builder->addListItemIndex(list);
+}
+
+/*! Adds the result of a list contains item from the  check to the code. */
+void Compiler::addListContains(List *list)
+{
+    impl->builder->addListContains(list);
+}
+
+/*! Adds the length of the given list to the code. */
+void Compiler::addListSize(List *list)
+{
+    impl->builder->addListSize(list);
+}
+
 /*! Compiles the given input (resolved by name) and adds it to the compiled code. */
 void Compiler::addInput(const std::string &name)
 {
@@ -268,6 +292,39 @@ void Compiler::createVariableWrite(Variable *variable)
     impl->builder->createVariableWrite(variable);
 }
 
+/*! Creates a clear list operation. */
+void Compiler::createListClear(List *list)
+{
+    impl->builder->createListClear(list);
+}
+
+/*!
+ * Creates a remove item from list operation.
+ * \note The index starts with 0 and is cast to number, special strings like "last" are not handled.
+ */
+void Compiler::createListRemove(List *list)
+{
+    impl->builder->createListRemove(list);
+}
+
+/*! Creates a list append operation using the last value. */
+void Compiler::createListAppend(List *list)
+{
+    impl->builder->createListAppend(list);
+}
+
+/*! Creates a list insert operation using the last 2 values (index, value). */
+void Compiler::createListInsert(List *list)
+{
+    impl->builder->createListInsert(list);
+}
+
+/*! Creates a list replace operation using the last 2 values (index, value). */
+void Compiler::createListReplace(List *list)
+{
+    impl->builder->createListReplace(list);
+}
+
 /*!
  * Starts a custom if statement.
  * \note The if statement must be terminated using endIf() after compiling your block.
diff --git a/test/dev/compiler/compiler_test.cpp b/test/dev/compiler/compiler_test.cpp
index 822eb358..9042a515 100644
--- a/test/dev/compiler/compiler_test.cpp
+++ b/test/dev/compiler/compiler_test.cpp
@@ -132,6 +132,70 @@ TEST_F(CompilerTest, AddListContents)
     compile(compiler, block);
 }
 
+TEST_F(CompilerTest, AddListItem)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("a", "");
+    block->setCompileFunction([](Compiler *compiler) {
+        List list1("", ""), list2("", "");
+        EXPECT_CALL(*m_builder, addListItem(&list1));
+        compiler->addListItem(&list1);
+
+        EXPECT_CALL(*m_builder, addListItem(&list2));
+        compiler->addListItem(&list2);
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, AddListItemIndex)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("a", "");
+    block->setCompileFunction([](Compiler *compiler) {
+        List list1("", ""), list2("", "");
+        EXPECT_CALL(*m_builder, addListItemIndex(&list1));
+        compiler->addListItemIndex(&list1);
+
+        EXPECT_CALL(*m_builder, addListItemIndex(&list2));
+        compiler->addListItemIndex(&list2);
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, AddListSize)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("a", "");
+    block->setCompileFunction([](Compiler *compiler) {
+        List list1("", ""), list2("", "");
+        EXPECT_CALL(*m_builder, addListSize(&list1));
+        compiler->addListSize(&list1);
+
+        EXPECT_CALL(*m_builder, addListSize(&list2));
+        compiler->addListSize(&list2);
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, AddListContains)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("a", "");
+    block->setCompileFunction([](Compiler *compiler) {
+        List list1("", ""), list2("", "");
+        EXPECT_CALL(*m_builder, addListContains(&list1));
+        compiler->addListContains(&list1);
+
+        EXPECT_CALL(*m_builder, addListContains(&list2));
+        compiler->addListContains(&list2);
+    });
+
+    compile(compiler, block);
+}
+
 TEST_F(CompilerTest, AddInput)
 {
     Compiler compiler(&m_engine, &m_target);