add CI

.github/workflows/premerge.yml

@@ -0,0 +1,33 @@
+name: Premerge
+
+on:
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  BUILD_TYPE: Release
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install LLVM
+      run: |
+        wget https://apt.llvm.org/llvm.sh
+        chmod +x llvm.sh
+        sudo ./llvm.sh 20
+        sudo apt install libmlir-20-dev mlir-20-tools
+
+    - name: Configure CMake
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DENABLE_CACHE=OFF
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+    - name: Test
+      working-directory: ${{github.workspace}}/build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --target test
+

integration/program.cpp

@@ -88,7 +88,7 @@ template<typename T> void assert_interpreter_object_value(std::string name, T ex
 			auto key_ = p->operator[](0);
 			auto value_ = p->operator[](1);
 			// only support string keys for now
-			ASSERT(key_.unwrap())
+			ASSERT(key_.unwrap());
 			auto key_string = as<PyString>(key_.unwrap())->value();
 			check_value(value_.unwrap(), expected_value[key_string]);
 		}

src/CMakeLists.txt

@@ -298,7 +298,7 @@ target_link_libraries(python-cpp
 )
 
 # LLVM backend
-find_package(LLVM CONFIG 20.0)
+find_package(LLVM CONFIG 20.1)
 if(ENABLE_LLVM_BACKEND AND NOT LLVM_FOUND)
   message(FATAL_ERROR "Could not find LLVM in the local environment")
 elseif(ENABLE_LLVM_BACKEND AND LLVM_FOUND)

src/ast/AST.hpp

@@ -1187,7 +1187,7 @@ class Subscript : public ASTNode
 	const std::shared_ptr<ASTNode> &value() const { return m_value; }
 	const SliceType &slice() const
 	{
-		ASSERT(m_slice)
+		ASSERT(m_slice);
 		return *m_slice;
 	}
 	ContextType context() const { return m_ctx; }
@@ -1304,7 +1304,7 @@ class Assert : public ASTNode
 		: ASTNode(ASTNodeType::Assert, source_location), m_test(std::move(test)),
 		  m_msg(std::move(msg))
 	{
-		ASSERT(m_test)
+		ASSERT(m_test);
 	}
 
 	const std::shared_ptr<ASTNode> &test() const { return m_test; }

src/ast/optimizers/ConstantFolding.cpp

@@ -11,8 +11,8 @@ namespace optimizer {
 			&& node->rhs()->node_type() == ASTNodeType::Constant) {
 			const auto &lhs = as<Constant>(node->lhs())->value();
 			const auto &rhs = as<Constant>(node->rhs())->value();
-			ASSERT(lhs)
-			ASSERT(rhs)
+			ASSERT(lhs);
+			ASSERT(rhs);
 			switch (node->op_type()) {
 			case BinaryOpType::PLUS: {
 				auto result = std::visit(

src/executable/Label.hpp

@@ -24,7 +24,7 @@ class Label
   protected:
 	void set_position(int64_t position) const
 	{
-		ASSERT(!m_position.has_value())
+		ASSERT(!m_position.has_value());
 		m_position = position;
 	}
 

src/executable/Mangler.cpp

@@ -62,8 +62,8 @@ class DefaultMangler : public Mangler
 
 		std::string_view mangled_class{ mangled_name.c_str() + start, end - start };
 
-		ASSERT(mangled_class.starts_with("__class__"))
-		ASSERT(mangled_class.ends_with("__"))
+		ASSERT(mangled_class.starts_with("__class__"));
+		ASSERT(mangled_class.ends_with("__"));
 
 		// extract name from __class__{}__
 		return std::string{ mangled_class.begin() + 9, mangled_class.end() - 2 };

src/executable/bytecode/Bytecode.cpp

@@ -125,14 +125,14 @@ py::PyResult<py::Value> Bytecode::eval_loop(VirtualMachine &vm, Interpreter &int
 	const auto end_instruction_it = end();
 	for (; vm.instruction_pointer() != end_instruction_it;
 		 vm.set_instruction_pointer(std::next(vm.instruction_pointer()))) {
-		ASSERT((*vm.instruction_pointer()).get())
+		ASSERT((*vm.instruction_pointer()).get());
 		const auto &current_ip = vm.instruction_pointer();
 		const auto &instruction = *current_ip;
 		spdlog::debug("{} {}", (void *)instruction.get(), instruction->to_string());
 		auto result = instruction->execute(vm, vm.interpreter());
 		// we left the current stack frame in the previous instruction
 		if (vm.stack().size() != stack_depth) {
-			ASSERT(result.is_ok())
+			ASSERT(result.is_ok());
 			return result;
 		}
 		// vm.dump();
@@ -143,7 +143,7 @@ py::PyResult<py::Value> Bytecode::eval_loop(VirtualMachine &vm, Interpreter &int
 			PyTraceback *tb_next = exception->traceback();
 			auto traceback =
 				PyTraceback::create(interpreter.execution_frame(), tb_lasti, tb_lineno, tb_next);
-			ASSERT(traceback.is_ok())
+			ASSERT(traceback.is_ok());
 			exception->set_traceback(traceback.unwrap());
 
 			interpreter.raise_exception(exception);
@@ -165,6 +165,6 @@ py::PyResult<py::Value> Bytecode::eval_loop(VirtualMachine &vm, Interpreter &int
 		}
 	}
 
-	ASSERT(value.has_value())
+	ASSERT(value.has_value());
 	return Ok(*value);
 }

src/executable/bytecode/BytecodeProgram.cpp

@@ -104,14 +104,14 @@ size_t BytecodeProgram::main_stack_size() const { return m_main_function->regist
 InstructionVector::const_iterator BytecodeProgram::begin() const
 {
 	// FIXME: assumes all functions are bytecode
-	ASSERT(m_main_function->function()->backend() == FunctionExecutionBackend::BYTECODE)
+	ASSERT(m_main_function->function()->backend() == FunctionExecutionBackend::BYTECODE);
 	return static_cast<Bytecode *>(m_main_function->function().get())->begin();
 }
 
 InstructionVector::const_iterator BytecodeProgram::end() const
 {
 	// FIXME: assumes all functions are bytecode
-	ASSERT(m_main_function->function()->backend() == FunctionExecutionBackend::BYTECODE)
+	ASSERT(m_main_function->function()->backend() == FunctionExecutionBackend::BYTECODE);
 	return static_cast<Bytecode *>(m_main_function->function().get())->end();
 }
 
@@ -136,7 +136,7 @@ int BytecodeProgram::execute(VirtualMachine *vm)
 
 	if (result.is_err()) {
 		auto *exception = interpreter.execution_frame()->pop_exception();
-		ASSERT(exception == result.unwrap_err())
+		ASSERT(exception == result.unwrap_err());
 		std::cout << exception->format_traceback() << std::endl;
 
 		// if (interpreter.execution_frame()->exception_info().has_value()) {
@@ -214,7 +214,7 @@ std::vector<uint8_t> BytecodeProgram::serialize() const
 	}
 
 	// TODO: Add support to serialize functions from different backends
-	ASSERT(m_backends.empty())
+	ASSERT(m_backends.empty());
 
 	return result;
 }
@@ -226,14 +226,14 @@ std::shared_ptr<BytecodeProgram> BytecodeProgram::deserialize(const std::vector<
 
 	auto span = std::span{ buffer };
 	auto deserialized_result = PyCode::deserialize(span, program);
-	ASSERT(deserialized_result.first.is_ok())
+	ASSERT(deserialized_result.first.is_ok());
 	program->m_main_function = deserialized_result.first.unwrap();
 	spdlog::debug(
 		"Deserialized main function:\n{}\n\n", program->m_main_function->function()->to_string());
 
 	while (!span.empty()) {
 		deserialized_result = PyCode::deserialize(span, program);
-		ASSERT(deserialized_result.first.is_ok())
+		ASSERT(deserialized_result.first.is_ok());
 		program->m_functions.push_back(deserialized_result.first.unwrap());
 		spdlog::debug("Deserialized function {}:\n{}\n\n",
 			program->m_functions.back()->function()->function_name(),

src/executable/bytecode/BytecodeProgram_tests.cpp

@@ -15,7 +15,7 @@ std::shared_ptr<BytecodeProgram> generate_bytecode(std::string_view program)
 	p.parse();
 
 	auto module = as<ast::Module>(p.module());
-	ASSERT(module)
+	ASSERT(module);
 
 	return std::static_pointer_cast<BytecodeProgram>(compiler::compile(
 		module, {}, compiler::Backend::BYTECODE_GENERATOR, compiler::OptimizationLevel::None));

src/executable/bytecode/Bytecode_tests.cpp

@@ -17,7 +17,7 @@
 // 	p.parse();
 
 // 	auto module = as<ast::Module>(p.module());
-// 	ASSERT(module)
+// 	ASSERT(module);
 
 // 	auto bytecode =
 // 		codegen::BytecodeGenerator::compile(module, {}, compiler::OptimizationLevel::None);