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

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

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

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

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

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

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

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