precommit hook

Author: gf712

.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