Compiler: Add list methods

Author: adazem009

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();

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.

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);