diff --git a/checker.c b/checker.c
index 4f7ba8f..e78c0bb 100644
--- a/checker.c
+++ b/checker.c
@@ -63,107 +63,108 @@ int string_symbol_map_set(StringSymbolMap* map, size_t key_hash, Symbol value)
 
 int statements_symbols_vec_construct(StatementsSymbolsVec* vec)
 {
-	const size_t start_capacity = 4;
-	StatementsSymbols* data = malloc(start_capacity * sizeof(StatementsSymbols));
-	if (data == NULL) {
-		return -1;
-	}
-	*vec = (StatementsSymbolsVec) {
-		.data = data,
-		.length = 0,
-		.capacity = start_capacity,
-	};
-	return 0;
+    const size_t start_capacity = 4;
+    StatementsSymbols* data
+        = malloc(start_capacity * sizeof(StatementsSymbols));
+    if (data == NULL) {
+        return -1;
+    }
+    *vec = (StatementsSymbolsVec) {
+        .data = data,
+        .length = 0,
+        .capacity = start_capacity,
+    };
+    return 0;
 }
 
 void statements_symbols_vec_destroy(StatementsSymbolsVec* vec)
 {
-	if (vec->data != NULL) {
-		free(vec->data);
-	}
+    if (vec->data != NULL) {
+        free(vec->data);
+    }
 }
 
-int statements_symbols_vec_push(StatementsSymbolsVec* vec, StatementsSymbols pair)
+int statements_symbols_vec_push(
+    StatementsSymbolsVec* vec, StatementsSymbols pair)
 {
-	if (vec->length + 1 > vec->capacity) {
-		StatementsSymbols* new_data = realloc(vec->data, vec->capacity * 2 * sizeof(StatementsSymbols));
-		if (new_data == NULL) {
-			return -1;
-		}
-		vec->capacity *= 2;
-		vec->data = new_data;
-	}
-	vec->data[vec->length] = pair;
-	vec->length += 1;
-	return 0;
+    if (vec->length + 1 > vec->capacity) {
+        StatementsSymbols* new_data
+            = realloc(vec->data, vec->capacity * 2 * sizeof(StatementsSymbols));
+        if (new_data == NULL) {
+            return -1;
+        }
+        vec->capacity *= 2;
+        vec->data = new_data;
+    }
+    vec->data[vec->length] = pair;
+    vec->length += 1;
+    return 0;
 }
 
 void symbol_table_construct(SymbolTable* table, SymbolTable* parent)
 {
-	*table = (SymbolTable) {
-		.parent = parent,
-		.map = { 0 },
-	};
-	string_symbol_map_construct(&table->map);
+    *table = (SymbolTable) {
+        .parent = parent,
+        .map = { 0 },
+    };
+    string_symbol_map_construct(&table->map);
 }
 
 void symbol_table_destroy(SymbolTable* table)
 {
-	string_symbol_map_destroy(&table->map);
+    string_symbol_map_destroy(&table->map);
 }
 
 void checker_construct(Checker* checker)
 {
     *checker = (Checker) {
         .failed = false,
-		.statements_symbols = { 0 },
+        .statements_symbols = { 0 },
     };
-	statements_symbols_vec_construct(&checker->statements_symbols);
+    statements_symbols_vec_construct(&checker->statements_symbols);
 }
 
-void checker_destroy(Checker* checker)
-{
-	(void)checker;
-}
+void checker_destroy(Checker* checker) { (void)checker; }
 
 bool checker_failed(const Checker* checker) { return checker->failed; }
 
 CheckerResult checker_result(Checker* checker)
 {
-	return (CheckerResult) {
-		.head_table = checker->head_table,
-		.statements_symbols = checker->statements_symbols,
-	};
+    return (CheckerResult) {
+        .head_table = checker->head_table,
+        .statements_symbols = checker->statements_symbols,
+    };
 }
 
 void checker_check_statements(Checker* checker, ASTNode* node)
 {
-	SymbolTable table;
-	symbol_table_construct(&table, &checker->head_table);
+    SymbolTable table;
+    symbol_table_construct(&table, &checker->head_table);
     for (size_t i = 0; i < node->statements.length; ++i) {
-		checker_check_statement(checker, &table, node->statements.data[i]);
-	}
-	statements_symbols_vec_push(&checker->statements_symbols, (StatementsSymbols) {
-		.table = table,
-		.statements = node,
-	});
+        checker_check_statement(checker, &table, node->statements.data[i]);
+    }
+    statements_symbols_vec_push(&checker->statements_symbols,
+        (StatementsSymbols) {
+            .table = table,
+            .statements = node,
+        });
 }
 
-
-void checker_check_statement(Checker* checker, SymbolTable* table, ASTNode* node)
+void checker_check_statement(
+    Checker* checker, SymbolTable* table, ASTNode* node)
 {
-	switch (node->node_type) {
-            case ASTNodeType_Block:
-				checker_check_statements(checker, node);
-            case ASTNodeType_If:
-            case ASTNodeType_Loop:
-            case ASTNodeType_Assign:
-            case ASTNodeType_Let:
-            case ASTNodeType_Break:
-            case ASTNodeType_Fn:
-            case ASTNodeType_Return:
-                break;
-			default:
-				break;
-        }
+    switch (node->node_type) {
+        case ASTNodeType_Block:
+            checker_check_statements(checker, node);
+        case ASTNodeType_If:
+        case ASTNodeType_Loop:
+        case ASTNodeType_Assign:
+        case ASTNodeType_Let:
+        case ASTNodeType_Break:
+        case ASTNodeType_Fn:
+        case ASTNodeType_Return:
+            break;
+        default:
+            break;
+    }
 }