precommit hook

.clang-format-ignore

@@ -0,0 +1,2 @@
+src/runtime/frozen/importlib.h
+src/runtime/frozen/importlib_external.h

.github/workflows/premerge.yml

@@ -14,6 +14,10 @@ jobs:
     steps:
     - uses: actions/checkout@v4
 
+    - uses: actions/setup-python@v3
+
+    - uses: pre-commit/action@v3.0.1
+
     - name: Install LLVM
       run: |
         wget https://apt.llvm.org/llvm.sh

.pre-commit-config.yaml

@@ -0,0 +1,5 @@
+repos:
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: 'v20.1.8'
+    hooks:
+    - id: clang-format

src/ast/AST.cpp

@@ -14,11 +14,8 @@ namespace ast {
 AST_NODE_TYPES
 #undef __AST_NODE_TYPE
 
-#define __AST_NODE_TYPE(NodeType)                            \
-	Value *NodeType::codegen(CodeGenerator *generator) const \
-	{                                                        \
-		return generator->visit(this);                       \
-	}
+#define __AST_NODE_TYPE(NodeType) \
+	Value *NodeType::codegen(CodeGenerator *generator) const { return generator->visit(this); }
 AST_NODE_TYPES
 #undef __AST_NODE_TYPE
 
@@ -34,11 +31,8 @@ void NodeVisitor::dispatch(ASTNode *node)
 #undef __AST_NODE_TYPE
 }
 
-#define __AST_NODE_TYPE(NodeType)              \
-	void NodeVisitor::dispatch(NodeType *node) \
-	{                                          \
-		visit(node);                           \
-	}
+#define __AST_NODE_TYPE(NodeType) \
+	void NodeVisitor::dispatch(NodeType *node) { visit(node); }
 AST_NODE_TYPES
 #undef __AST_NODE_TYPE
 

src/ast/optimizers/Optimizers_tests.cpp

@@ -1,9 +1,9 @@
 #include "ConstantFolding.hpp"
 #include "ast/AST.hpp"
+#include "executable/Program.hpp"
 #include "parser/Parser.hpp"
 #include "runtime/Value.hpp"
 #include "utilities.hpp"
-#include "executable/Program.hpp"
 
 #include "gtest/gtest.h"
 
@@ -502,7 +502,7 @@ TEST(Optimizer, ConstantFoldIntegerAddition)
 	expected_ast->emplace(
 		std::make_shared<Assign>(std::vector<std::shared_ptr<ASTNode>>{ std::make_shared<Name>(
 									 "a", ContextType::STORE, SourceLocation{}) },
-			std::make_shared<Constant>(BigIntType{2}, SourceLocation{}),
+			std::make_shared<Constant>(BigIntType{ 2 }, SourceLocation{}),
 			"",
 			SourceLocation{}));
 

src/executable/Program.cpp

@@ -2,8 +2,8 @@
 #include "executable/bytecode/codegen/BytecodeGenerator.hpp"
 #include "executable/llvm/LLVMGenerator.hpp"
 #include "executable/mlir/Dialect/Python/MLIRGenerator.hpp"
-#include "utilities.hpp"
 #include "mlir/compile.hpp"
+#include "utilities.hpp"
 
 
 Program::Program(std::string &&filename, std::vector<std::string> &&argv)
@@ -34,4 +34,4 @@ std::shared_ptr<Program> compile(std::shared_ptr<ast::Module> node,
 	}
 	ASSERT_NOT_REACHED();
 }
-}
+}// namespace compiler

src/executable/bytecode/Bytecode.cpp

@@ -17,11 +17,11 @@ Bytecode::Bytecode(size_t register_count,
 	InstructionVector instructions,
 	std::shared_ptr<Program> program)
 	: Function(register_count,
-		locals_count,
-		stack_size,
-		function_name,
-		FunctionExecutionBackend::BYTECODE,
-		std::move(program)),
+		  locals_count,
+		  stack_size,
+		  function_name,
+		  FunctionExecutionBackend::BYTECODE,
+		  std::move(program)),
 	  m_instructions(std::move(instructions))
 {}
 
@@ -78,8 +78,12 @@ std::unique_ptr<Bytecode> Bytecode::deserialize(std::span<const uint8_t> &buffer
 		instructions.push_back(std::move(instruction));
 	}
 
-	return std::make_unique<Bytecode>(
-		register_count, locals_count, stack_size, function_name, std::move(instructions), std::move(program));
+	return std::make_unique<Bytecode>(register_count,
+		locals_count,
+		stack_size,
+		function_name,
+		std::move(instructions),
+		std::move(program));
 }
 
 PyResult<Value> Bytecode::call(VirtualMachine &vm, Interpreter &interpreter) const
@@ -124,7 +128,7 @@ 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()))) {
+		vm.set_instruction_pointer(std::next(vm.instruction_pointer()))) {
 		ASSERT((*vm.instruction_pointer()).get());
 		const auto &current_ip = vm.instruction_pointer();
 		const auto &instruction = *current_ip;

src/executable/bytecode/Bytecode.hpp

@@ -31,7 +31,8 @@ class Bytecode : public Function
 
 	std::vector<uint8_t> serialize() const override;
 
-	static std::unique_ptr<Bytecode> deserialize(std::span<const uint8_t> &buffer, std::shared_ptr<Program> program);
+	static std::unique_ptr<Bytecode> deserialize(std::span<const uint8_t> &buffer,
+		std::shared_ptr<Program> program);
 
 	py::PyResult<py::Value> call(VirtualMachine &, Interpreter &) const override;
 	py::PyResult<py::Value> call_without_setup(VirtualMachine &, Interpreter &) const override;

src/executable/bytecode/codegen/BytecodeGenerator.cpp

@@ -34,9 +34,9 @@
 #include "executable/bytecode/instructions/Instructions.hpp"
 #include "executable/bytecode/instructions/Jump.hpp"
 #include "executable/bytecode/instructions/JumpForward.hpp"
+#include "executable/bytecode/instructions/JumpIfExceptionMatch.hpp"
 #include "executable/bytecode/instructions/JumpIfFalse.hpp"
 #include "executable/bytecode/instructions/JumpIfFalseOrPop.hpp"
-#include "executable/bytecode/instructions/JumpIfExceptionMatch.hpp"
 #include "executable/bytecode/instructions/JumpIfNotExceptionMatch.hpp"
 #include "executable/bytecode/instructions/JumpIfTrue.hpp"
 #include "executable/bytecode/instructions/JumpIfTrueOrPop.hpp"
@@ -277,7 +277,7 @@ void BytecodeGenerator::store_name(const std::string &name, BytecodeValue *src)
 			ASSERT(visibility->second->type == VariablesResolver::Scope::Type::CLASS);
 			return *it;
 		} else if (auto it = visibility->second->symbol_map.get_visible_symbol(name);
-				   it.has_value()) {
+			it.has_value()) {
 			return *it;
 		} else {
 			TODO();
@@ -396,7 +396,7 @@ void BytecodeGenerator::delete_var(const std::string &name)
 			ASSERT(visibility->second->type == VariablesResolver::Scope::Type::CLASS);
 			return *it;
 		} else if (auto it = visibility->second->symbol_map.get_visible_symbol(name);
-				   it.has_value()) {
+			it.has_value()) {
 			return *it;
 		} else {
 			TODO();
@@ -699,7 +699,7 @@ Value *BytecodeGenerator::generate_function(const FunctionType *node)
 		idx++;
 	}
 	for (size_t idx = node->args()->argument_names().size();
-		 const auto &arg_name : node->args()->kw_only_argument_names()) {
+		const auto &arg_name : node->args()->kw_only_argument_names()) {
 		varnames.push_back(arg_name);
 		ASSERT(symbol_map.get_visible_symbol(arg_name).has_value());
 		if (std::find(cellvars.begin(), cellvars.end(), arg_name) != cellvars.end()) {
@@ -950,7 +950,7 @@ Value *BytecodeGenerator::visit(const Lambda *node)
 		idx++;
 	}
 	for (size_t idx = node->args()->argument_names().size();
-		 const auto &arg_name : node->args()->kw_only_argument_names()) {
+		const auto &arg_name : node->args()->kw_only_argument_names()) {
 		varnames.push_back(arg_name);
 		ASSERT(symbol_map.get_visible_symbol(arg_name).has_value());
 		if (std::find(cellvars.begin(), cellvars.end(), arg_name) != cellvars.end()) {

src/executable/bytecode/codegen/VariablesResolver.cpp

@@ -9,7 +9,9 @@ using namespace ast;
 
 namespace {
 bool captured_by_closure(VariablesResolver::Visibility v)
-{ return v == VariablesResolver::Visibility::CELL || v == VariablesResolver::Visibility::FREE; }
+{
+	return v == VariablesResolver::Visibility::CELL || v == VariablesResolver::Visibility::FREE;
+}
 }// namespace
 
 

src/executable/bytecode/instructions/BuildList.hpp

@@ -9,14 +9,11 @@ class BuildList final : public Instruction
 	size_t m_size;
 
   public:
-	BuildList(Register dst, size_t size)
-		: m_dst(dst), m_size(size)
-	{}
+	BuildList(Register dst, size_t size) : m_dst(dst), m_size(size) {}
 
 	std::string to_string() const final
 	{
-		return fmt::format(
-			"BUILD_LIST      r{:<3} (size={})", m_dst, m_size);
+		return fmt::format("BUILD_LIST      r{:<3} (size={})", m_dst, m_size);
 	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &, Interpreter &) const final;

src/executable/bytecode/instructions/DeleteFast.cpp

@@ -7,7 +7,7 @@ using namespace py;
 PyResult<Value> DeleteFast::execute(VirtualMachine &vm, Interpreter &) const
 {
 	vm.stack_local(m_stack_index) = nullptr;
-    return Ok(py_none());
+	return Ok(py_none());
 }
 
 std::vector<uint8_t> DeleteFast::serialize() const

src/executable/bytecode/instructions/ForIter.hpp

@@ -26,9 +26,7 @@ class ForIter final : public Instruction
 		  m_exit_label(std::move(exit_label))
 	{}
 
-	ForIter(Register dst, Register src, int32_t offset)
-		: ForIter(dst, src, offset, int32_t{ 0 })
-	{}
+	ForIter(Register dst, Register src, int32_t offset) : ForIter(dst, src, offset, int32_t{ 0 }) {}
 
 	ForIter(Register dst, Register src, int32_t offset, int32_t body_offset)
 		: m_dst(dst), m_src(src), m_offset(offset), m_body_offset(body_offset)

src/executable/bytecode/instructions/InplaceOp.cpp

@@ -1,7 +1,7 @@
 #include "InplaceOp.hpp"
+#include "runtime/PyObject.hpp"
 #include "runtime/Value.hpp"
 #include "vm/VM.hpp"
-#include "runtime/PyObject.hpp"
 
 using namespace py;
 

src/executable/bytecode/instructions/MakeFunction.cpp

@@ -14,7 +14,7 @@ PyResult<Value> MakeFunction::execute(VirtualMachine &vm, Interpreter &interpret
 	std::vector<Value> default_values;
 	default_values.reserve(m_defaults_size);
 	auto *start = vm.sp() - m_defaults_size - m_kw_defaults_size;
-	while (start != (vm.sp()- m_kw_defaults_size)) {
+	while (start != (vm.sp() - m_kw_defaults_size)) {
 		default_values.push_back(*start);
 		start = std::next(start);
 	}

src/executable/bytecode/instructions/MakeFunction.hpp

@@ -21,7 +21,10 @@ class MakeFunction : public Instruction
 		  m_kw_defaults_size(kw_defaults_size), m_captures_tuple(std::move(captures_tuple))
 	{}
 
-	std::string to_string() const final { return fmt::format("MAKE_FUNCTION   r{}   ({})", m_dst, m_name); }
+	std::string to_string() const final
+	{
+		return fmt::format("MAKE_FUNCTION   r{}   ({})", m_dst, m_name);
+	}
 
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 

src/executable/bytecode/instructions/Push.cpp

@@ -7,7 +7,7 @@ using namespace py;
 PyResult<Value> Push::execute(VirtualMachine &vm, Interpreter &) const
 {
 	auto value = vm.reg(m_source);
-    vm.push(value);
+	vm.push(value);
 	return Ok(py_none());
 }
 

src/executable/bytecode/instructions/Push.hpp

@@ -8,10 +8,7 @@ class Push final : public Instruction
 
   public:
 	Push(Register source) : m_source(source) {}
-	std::string to_string() const final
-	{
-		return fmt::format("PUSH            r{:<3}", m_source);
-	}
+	std::string to_string() const final { return fmt::format("PUSH            r{:<3}", m_source); }
 	py::PyResult<py::Value> execute(VirtualMachine &vm, Interpreter &interpreter) const final;
 
 	void relocate(size_t) final {}

src/executable/mlir/Conversion/PythonToPythonBytecode/PythonToPythonBytecode.cpp

@@ -1819,7 +1819,7 @@ namespace py {
 								op, BlockRange{ cleanup_block });
 						}
 					} else if (auto op = mlir::dyn_cast<mlir::py::ControlFlowYield>(childOp);
-							   op && !op.getKind().has_value()) {
+						op && !op.getKind().has_value()) {
 						auto *current = op->getBlock();
 						auto *next = rewriter.splitBlock(current, op->getIterator());
 						rewriter.setInsertionPointToEnd(current);

src/executable/mlir/Dialect/Python/IR/Ops.cpp

@@ -195,7 +195,7 @@ namespace py {
 					 getHandlers().end(),
 					 [&point](
 						 mlir::Region &handler) { return point.getRegionOrNull() == &handler; });
-				 it != getHandlers().end()) {
+			it != getHandlers().end()) {
 			if (std::next(it) != getHandlers().end()) {
 				it++;
 				regions.emplace_back(&*it, it->getArguments());

src/executable/mlir/Dialect/Python/MLIRGenerator.cpp

@@ -346,7 +346,7 @@ void MLIRGenerator::store_name(std::string_view name,
 			ASSERT(visibility_map->type == VariablesResolver::Scope::Type::CLASS);
 			return it->get().visibility;
 		} else if (auto it = visibility_map->symbol_map.get_visible_symbol(std::string{ name });
-				   it.has_value()) {
+			it.has_value()) {
 			return it->get().visibility;
 		} else {
 			TODO();
@@ -434,7 +434,7 @@ MLIRGenerator::MLIRValue *MLIRGenerator::load_name(std::string_view name,
 			ASSERT(visibility_map->type == VariablesResolver::Scope::Type::CLASS);
 			return it->get().visibility;
 		} else if (auto it = visibility_map->symbol_map.get_visible_symbol(std::string{ name });
-				   it.has_value()) {
+			it.has_value()) {
 			return it->get().visibility;
 		} else {
 			TODO();
@@ -516,7 +516,7 @@ void MLIRGenerator::delete_name(std::string_view name, const SourceLocation &loc
 			ASSERT(visibility_map->type == VariablesResolver::Scope::Type::CLASS);
 			return it->get().visibility;
 		} else if (auto it = visibility_map->symbol_map.get_visible_symbol(std::string{ name });
-				   it.has_value()) {
+			it.has_value()) {
 			return it->get().visibility;
 		} else {
 			TODO();
@@ -1103,7 +1103,7 @@ ast::Value *MLIRGenerator::visit(const ast::Call *node)
 			}
 			arg_values.push_back(static_cast<MLIRValue *>(
 				build_tuple(args, arg_requires_expansion, node->source_location()))
-									 ->value);
+					->value);
 		}
 		if (!node->keywords().empty()) { requires_kwargs_expansion = true; }
 		{
@@ -1131,7 +1131,7 @@ ast::Value *MLIRGenerator::visit(const ast::Call *node)
 			}
 			keyword_values.push_back(static_cast<MLIRValue *>(
 				build_dict(keys, values, kwarg_requires_expansion, node->source_location()))
-										 ->value);
+					->value);
 		}
 	} else {
 		arg_values.reserve(node->args().size());
@@ -1584,9 +1584,9 @@ ast::Value *MLIRGenerator::visit(const ast::For *node)
 	for (const auto &el : node->body()) { el->codegen(this); }
 	if (m_context.builder().getInsertionBlock()->empty()
 		|| !m_context.builder()
-				.getInsertionBlock()
-				->back()
-				.hasTrait<mlir::OpTrait::IsTerminator>()) {
+			.getInsertionBlock()
+			->back()
+			.hasTrait<mlir::OpTrait::IsTerminator>()) {
 		m_context.builder().create<mlir::py::ControlFlowYield>(m_context.builder().getUnknownLoc());
 	}
 
@@ -2738,9 +2738,9 @@ ast::Value *MLIRGenerator::visit(const ast::Try *node)
 			for (auto el : handler->body()) { el->codegen(this); }
 			if (m_context.builder().getBlock()->empty()
 				|| !m_context.builder()
-						.getBlock()
-						->back()
-						.hasTrait<mlir::OpTrait::IsTerminator>()) {
+					.getBlock()
+					->back()
+					.hasTrait<mlir::OpTrait::IsTerminator>()) {
 				m_context.builder().create<mlir::py::ControlFlowYield>(
 					loc(m_context.builder(), m_context.filename(), node->source_location()));
 			}