Add more tests for List to test and iterators

include/serene/exprs/expression.h

@@ -49,10 +49,10 @@ enum class ExprType {
 
 class Expression;
 
-using node = std::unique_ptr<Expression>;
+using node = std::shared_ptr<Expression>;
 using maybe_node = Result<node>;
 
-using ast = llvm::SmallVector<node, 0>;
+using ast = std::vector<node>;
 using maybe_ast = Result<ast>;
 
 /// The base class of the expressions which provides the common interface for
@@ -88,7 +88,7 @@ public:
 ///              passed to the constructor of type T.
 /// \return A unique pointer to an Expression
 template <typename T, typename... Args> node make(Args &&...args) {
-  return std::make_unique<T>(std::forward<Args>(args)...);
+  return std::make_shared<T>(std::forward<Args>(args)...);
 };
 
 /// Create a new `node` of type `T` and forwards any given parameter
@@ -102,8 +102,8 @@ template <typename T, typename... Args> node make(Args &&...args) {
 ///              passed to the constructor of type T.
 /// \return A unique pointer to a value of type T.
 template <typename T, typename... Args>
-std::unique_ptr<T> makeAndCast(Args &&...args) {
-  return std::make_unique<T>(std::forward<Args>(args)...);
+std::shared_ptr<T> makeAndCast(Args &&...args) {
+  return std::make_shared<T>(std::forward<Args>(args)...);
 };
 
 void dump(ast &);

include/serene/exprs/list.h

@@ -27,7 +27,6 @@
 
 #include "serene/exprs/expression.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
 #include <string>
 
 namespace serene {
@@ -47,7 +46,8 @@ public:
 
   List(const reader::LocationRange &loc) : Expression(loc){};
   List(const reader::LocationRange &loc, node &e);
-  List(const reader::LocationRange &loc, llvm::MutableArrayRef<node> elems);
+  // List(const reader::LocationRange &loc, llvm::MutableArrayRef<node> elems);
+  List(const reader::LocationRange &loc, ast elems);
 
   ExprType getType() const;
   std::string toString() const;
@@ -61,10 +61,10 @@ public:
 
   llvm::Optional<Expression *> at(uint index);
 
-  llvm::SmallVector<node>::const_iterator cbegin();
-  llvm::SmallVector<node>::const_iterator cend();
-  llvm::SmallVector<node>::iterator begin();
-  llvm::SmallVector<node>::iterator end();
+  std::vector<node>::const_iterator cbegin();
+  std::vector<node>::const_iterator cend();
+  std::vector<node>::iterator begin();
+  std::vector<node>::iterator end();
 
   maybe_node analyze(reader::SemanticContext &);
 

src/serene/exprs/list.cpp

@@ -34,13 +34,15 @@ namespace exprs {
 
 List::List(const List &l) : Expression(l.location){};
 List::List(const reader::LocationRange &loc, node &e) : Expression(loc) {
-  elements.push_back(std::move(e));
+  elements.push_back(e);
 };
 
-List::List(const reader::LocationRange &loc, llvm::MutableArrayRef<node> elems)
-    : Expression(loc) {
-  std::move(elems.begin(), elems.end(), elements.begin());
-};
+// List::List(const reader::LocationRange &loc, llvm::MutableArrayRef<node>
+// elems)
+//   : Expression(loc), elements(elems.begin(), elems.end()) {};
+
+List::List(const reader::LocationRange &loc, ast elems)
+    : Expression(loc), elements(elems){};
 
 ExprType List::getType() const { return ExprType::List; };
 std::string List::toString() const {
@@ -84,21 +86,19 @@ bool List::classof(const Expression *e) {
 
 /// Return an iterator to be used with the `for` loop. It's implicitly called by
 /// the for loop.
-llvm::SmallVector<node>::const_iterator List::cbegin() {
-  return elements.begin();
-}
+std::vector<node>::const_iterator List::cbegin() { return elements.begin(); }
 
 /// Return an iterator to be used with the `for` loop. It's implicitly called by
 /// the for loop.
-llvm::SmallVector<node>::const_iterator List::cend() { return elements.end(); }
+std::vector<node>::const_iterator List::cend() { return elements.end(); }
 
 /// Return an iterator to be used with the `for` loop. It's implicitly called by
 /// the for loop.
-llvm::SmallVector<node>::iterator List::begin() { return elements.begin(); }
+std::vector<node>::iterator List::begin() { return elements.begin(); }
 
 /// Return an iterator to be used with the `for` loop. It's implicitly called by
 /// the for loop.
-llvm::SmallVector<node>::iterator List::end() { return elements.end(); }
+std::vector<node>::iterator List::end() { return elements.end(); }
 
 size_t List::count() const { return elements.size(); }
 

src/tests/exprs/list_tests.cpp.inc

@@ -1,4 +1,3 @@
-
 /* -*- C++ -*-
  * Serene programming language.
  *
@@ -26,6 +25,7 @@
 #include "../test_helpers.cpp.inc"
 #include "serene/exprs/list.h"
 #include "serene/exprs/symbol.h"
+#include <catch2/catch.hpp>
 
 namespace serene {
 namespace exprs {
@@ -33,38 +33,51 @@ namespace exprs {
 TEST_CASE("List Expression", "[expression]") {
   std::unique_ptr<reader::LocationRange> range(dummyLocation());
 
-  auto sym = make<Symbol>(*range.get(), llvm::StringRef("example"));
-  auto sym1 = make<Symbol>(*range.get(), llvm::StringRef("example1"));
+  node sym = make<Symbol>(*range.get(), llvm::StringRef("example"));
+  node sym1 = make<Symbol>(*range.get(), llvm::StringRef("example1"));
 
-  auto list = make<List>(*range.get());
+  node list = make<List>(*range.get());
 
   REQUIRE(list->getType() == ExprType::List);
   CHECK(list->toString() == "<List [loc: 2:20:40 | 3:30:80]: ->");
 
-  auto list2 = make<List>(*range.get(), list);
+  node list2 = make<List>(*range.get(), list);
   CHECK(list2->toString() ==
         "<List [loc: 2:20:40 | 3:30:80]:  <List [loc: 2:20:40 | 3:30:80]: ->>");
 
-  std::vector<node> elements;
-  elements.push_back(std::move(list));
-  elements.push_back(std::move(list2));
-  elements.push_back(std::move(sym));
+  ast elements;
+  elements.push_back(list);
+  elements.push_back(list2);
+  elements.push_back(sym);
 
-  auto list3 = make<List>(*range.get(), llvm::MutableArrayRef<node>(elements));
+  auto list3 = make<List>(*range.get(), elements);
 
   CHECK(list3->toString() ==
         "<List [loc: 2:20:40 | 3:30:80]:  <List [loc: 2:20:40 | 3:30:80]: -> "
         "<List [loc: 2:20:40 | 3:30:80]:  <List [loc: 2:20:40 | 3:30:80]: "
         "->> <Symbol [loc: 2:20:40 | 3:30:80]: example>>");
 
+  auto l = llvm::dyn_cast<List>(list.get());
 
-  // auto l = llvm::dyn_cast<List>(list3.get());
+  l->append(sym1);
 
-  // l->append(std::move(sym1));
+  REQUIRE(list->getType() == ExprType::List);
+  CHECK(list->toString() == "<List [loc: 2:20:40 | 3:30:80]:  <Symbol [loc: "
+                            "2:20:40 | 3:30:80]: example1>>");
 
-  // REQUIRE(list3->getType() == ExprType::List);
-  // CHECK(list3->toString() == "<List [loc: 2:20:40 | 3:30:80]:  <Symbol [loc: "
-  //                           "2:20:40 | 3:30:80]: example1>>");
+  l->append(sym);
+  REQUIRE(l->count() == 2);
+
+  auto expr = l->at(1);
+  REQUIRE(expr.hasValue());
+  CHECK(expr.getValue()->toString() == "<Symbol [loc: 2:20:40 | 3:30:80]: example>");
+
+  expr = l->at(2);
+  REQUIRE_FALSE(expr.hasValue());
+
+  for(auto x : *l) {
+    CHECK(x->getType() == ExprType::Symbol);
+  }
 };
 
 } // namespace exprs