Codegen: Don't allow variable shadowing of different type HEAD master

2 files changed, 171 insertions, 159 deletions

diff --git a/src/codegen.pry b/src/codegen.pry
index b2632c2..2bfa831 100644
--- a/src/codegen.pry
+++ b/src/codegen.pry
@@ -20,69 +20,6 @@ let Environment = struct {
 	arena: *arena,
 };
 
-let environment_create_scope = (e: *Environment) => void {
-	let scope = cast(*Scope, arena_alloc((*e).arena, sizeof(Scope)));
-	(*scope).variables = hashmap_init(16, (*e).arena);
-	(*((*e).scope_stack + cast(**Scope, (*e).scope_stack_len))) = scope;
-	(*e).scope_stack_len = (*e).scope_stack_len + 1;
-
-	return;
-};
-
-let environment_drop_scope = (e: *Environment) => void {
-	(*e).scope_stack_len = (*e).scope_stack_len - 1;
-
-	return;
-};
-
-let environment_get_variable = (e: *Environment, name: *i8) => *Variable {
-	let i = (*e).scope_stack_len;
-	let variable = cast(*Variable, null);
-
-	while i > 0 {
-		i = i - 1;
-		let scope = *(((*e).scope_stack + cast(**Scope, i)));
-		assert(scope != cast(*Scope, null));
-		let v = cast(*Variable, hashmap_get((*scope).variables, name));
-		if v != cast(*Variable, null) {
-			if variable == cast(*Variable, null) {
-				variable = v;
-			};
-			let stack_level = cast(*i64, arena_alloc((*e).arena, sizeof(i64)));
-			(*stack_level) = i;
-			(*variable).stack_level = stack_level;
-		};
-	};
-
-	return variable;
-};
-
-let environment_add_variable = (e: *Environment, name: *i8, variable: *Variable) => void {
-        /* TODO: Dont allow shadowing if value != value or type != type (across things) */
-	let top_scope = *(((*e).scope_stack + cast(**Scope, (*e).scope_stack_len - 1)));
-	hashmap_put((*top_scope).variables, name, cast(*void, variable));
-
-	return;
-};
-
-let environment_set_variable = (e: *Environment, name: *i8, variable: *Variable) => void {
-	let existing = environment_get_variable(e, name);
-	(*existing) = (*variable);
-
-	return;
-};
-
-let environment_init = (alloc: *arena) => *Environment {
-	let e = cast(*Environment, arena_alloc(alloc, sizeof(Environment)));
-	(*e).scope_stack = cast(**Scope, arena_alloc(alloc, sizeof(*Scope) * 40));
-	(*e).scope_stack_len = 0;
-	(*e).arena = alloc;
-
-	environment_create_scope(e);
-
-	return e;
-};
-
 let codegen = struct {
 	llvm_module: LLVMModuleRef,
 	llvm_context: LLVMContextRef,
@@ -97,41 +34,6 @@ let codegen = struct {
 	llvm_target_data: LLVMTargetDataRef,
 };
 
-let codegen_init = (alloc: *arena) => *codegen {
-	LLVMInitializeAllTargetInfos();
-	LLVMInitializeAllTargetMCs();
-	LLVMInitializeAllTargets();
-	LLVMInitializeAllAsmPrinters();
-	LLVMInitializeAllAsmParsers();
-
-	let module = LLVMModuleCreateWithName("module");
-        let context = LLVMGetGlobalContext();
-        let builder = LLVMCreateBuilder();
-	
-	let c = cast(*codegen, arena_alloc(alloc, sizeof(codegen)));
-	
-	(*c).llvm_module = module;
-	(*c).llvm_target_data = LLVMGetModuleDataLayout(module);
-	(*c).llvm_context = context;
-	(*c).builder = builder;
-	(*c).arena = alloc;
-	(*c).environment = environment_init(alloc);
-
-	return c;
-};
-
-let create_node = (c: *codegen, n: Node) => *Node {
-	let res = cast(*Node, arena_alloc((*c).arena, sizeof(Node)));
-	*res = n;
-	return res;
-};
-
-let codegen_create_variable = (c: *codegen, variable: Variable) => *Variable {
-	let v = cast(*Variable, arena_alloc((*c).arena, sizeof(Variable)));
-	*v = variable;
-	return v;
-};
-
 let compare_types = (c: *codegen, a: *Node, b: *Node, is_dereference: bool) => bool {
 	assert((*a).type >= NODE_TYPE_SIMPLE_TYPE and (*a).type <= NODE_TYPE_STRUCT_TYPE);
 	assert((*b).type >= NODE_TYPE_SIMPLE_TYPE and (*b).type <= NODE_TYPE_STRUCT_TYPE);
@@ -235,6 +137,107 @@ let compare_types = (c: *codegen, a: *Node, b: *Node, is_dereference: bool) => b
 	return false;
 };
 
+let environment_create_scope = (e: *Environment) => void {
+	let scope = cast(*Scope, arena_alloc((*e).arena, sizeof(Scope)));
+	(*scope).variables = hashmap_init(16, (*e).arena);
+	(*((*e).scope_stack + cast(**Scope, (*e).scope_stack_len))) = scope;
+	(*e).scope_stack_len = (*e).scope_stack_len + 1;
+
+	return;
+};
+
+let environment_drop_scope = (e: *Environment) => void {
+	(*e).scope_stack_len = (*e).scope_stack_len - 1;
+
+	return;
+};
+
+let environment_get_variable = (e: *Environment, name: *i8) => *Variable {
+	let i = (*e).scope_stack_len;
+	let variable = cast(*Variable, null);
+
+	while i > 0 {
+		i = i - 1;
+		let scope = *(((*e).scope_stack + cast(**Scope, i)));
+		assert(scope != cast(*Scope, null));
+		let v = cast(*Variable, hashmap_get((*scope).variables, name));
+		if v != cast(*Variable, null) {
+			if variable == cast(*Variable, null) {
+				variable = v;
+			};
+			let stack_level = cast(*i64, arena_alloc((*e).arena, sizeof(i64)));
+			(*stack_level) = i;
+			(*variable).stack_level = stack_level;
+		};
+	};
+
+	return variable;
+};
+
+let environment_add_variable = (e: *Environment, name: *i8, variable: *Variable) => void {
+	let existing = environment_get_variable(e, name);
+	if existing != cast(*Variable, null) {
+		assert(compare_types(cast(*codegen, null), (*existing).node_type, (*variable).node_type, false));
+	};
+	let top_scope = *(((*e).scope_stack + cast(**Scope, (*e).scope_stack_len - 1)));
+	hashmap_put((*top_scope).variables, name, cast(*void, variable));
+
+	return;
+};
+
+let environment_set_variable = (e: *Environment, name: *i8, variable: *Variable) => void {
+	let existing = environment_get_variable(e, name);
+	(*existing) = (*variable);
+
+	return;
+};
+
+let environment_init = (alloc: *arena) => *Environment {
+	let e = cast(*Environment, arena_alloc(alloc, sizeof(Environment)));
+	(*e).scope_stack = cast(**Scope, arena_alloc(alloc, sizeof(*Scope) * 40));
+	(*e).scope_stack_len = 0;
+	(*e).arena = alloc;
+
+	environment_create_scope(e);
+
+	return e;
+};
+
+let codegen_init = (alloc: *arena) => *codegen {
+	LLVMInitializeAllTargetInfos();
+	LLVMInitializeAllTargetMCs();
+	LLVMInitializeAllTargets();
+	LLVMInitializeAllAsmPrinters();
+	LLVMInitializeAllAsmParsers();
+
+	let module = LLVMModuleCreateWithName("module");
+        let context = LLVMGetGlobalContext();
+        let builder = LLVMCreateBuilder();
+	
+	let c = cast(*codegen, arena_alloc(alloc, sizeof(codegen)));
+	
+	(*c).llvm_module = module;
+	(*c).llvm_target_data = LLVMGetModuleDataLayout(module);
+	(*c).llvm_context = context;
+	(*c).builder = builder;
+	(*c).arena = alloc;
+	(*c).environment = environment_init(alloc);
+
+	return c;
+};
+
+let codegen_create_node = (c: *codegen, n: Node) => *Node {
+	let res = cast(*Node, arena_alloc((*c).arena, sizeof(Node)));
+	*res = n;
+	return res;
+};
+
+let codegen_create_variable = (c: *codegen, variable: Variable) => *Variable {
+	let v = cast(*Variable, arena_alloc((*c).arena, sizeof(Variable)));
+	*v = variable;
+	return v;
+};
+
 let codegen_get_llvm_type = (c: *codegen, node: *Node) => *LLVMTypeRef {
 	assert((*node).type >= NODE_TYPE_SIMPLE_TYPE and (*node).type <= NODE_TYPE_STRUCT_TYPE);
 	
@@ -318,9 +321,9 @@ let codegen_get_llvm_type = (c: *codegen, node: *Node) => *LLVMTypeRef {
 
 			i = i + 1;
 		};
-		let function_type = LLVMFunctionType(*retur_type, paramtypes, paramtypes_len, is_varargs);
+		let llvm_function_type = LLVMFunctionType(*retur_type, paramtypes, paramtypes_len, is_varargs);
 		let r = cast(*LLVMTypeRef, arena_alloc((*c).arena, sizeof(LLVMTypeRef)));
-		*r = function_type;
+		*r = llvm_function_type;
 		return r;
 	};
 
@@ -461,12 +464,12 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		inner_type.data = cast(*void, inner_type_data);
 
 		let node_type_data = cast(*NODE_TYPE_POINTER_TYPE_DATA, arena_alloc((*c).arena, sizeof(NODE_TYPE_POINTER_TYPE_DATA)));
-		(*node_type_data).type = create_node(c, inner_type);
+		(*node_type_data).type = codegen_create_node(c, inner_type);
 		let node_type = Node{};
 		node_type.type = NODE_TYPE_POINTER_TYPE;
 		node_type.data = cast(*void, node_type_data);
 
-		return codegen_generate_literal(c, LLVMConstNull(LLVMPointerType(LLVMInt8Type(), 0)), name, expression, create_node(c, node_type));
+		return codegen_generate_literal(c, LLVMConstNull(LLVMPointerType(LLVMInt8Type(), 0)), name, expression, codegen_create_node(c, node_type));
 	};
 
 	if ((*expression).type == NODE_PRIMARY_EXPRESSION_NUMBER) {
@@ -480,7 +483,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		(*d).underlying_type = cast(*Node, null);
 		node_type.data = cast(*void, d);
 		
-		return codegen_generate_literal(c, LLVMConstInt(LLVMInt64Type(), n, 0), name, expression, create_node(c, node_type));
+		return codegen_generate_literal(c, LLVMConstInt(LLVMInt64Type(), n, 0), name, expression, codegen_create_node(c, node_type));
 	};
 	
 	if ((*expression).type == NODE_PRIMARY_EXPRESSION_BOOLEAN) {
@@ -499,7 +502,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 			int_value = 1;
 		};
 		
-		return codegen_generate_literal(c, LLVMConstInt(LLVMInt1Type(), int_value, 0), name, expression, create_node(c, node_type));
+		return codegen_generate_literal(c, LLVMConstInt(LLVMInt1Type(), int_value, 0), name, expression, codegen_create_node(c, node_type));
 	};
 	
 	if ((*expression).type == NODE_PRIMARY_EXPRESSION_CHAR) {
@@ -513,7 +516,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		(*d).underlying_type = cast(*Node, null);
 		node_type.data = cast(*void, d);
 		
-		return codegen_generate_literal(c, LLVMConstInt(LLVMInt8Type(), cast(i64, ch), 0), name, expression, create_node(c, node_type));
+		return codegen_generate_literal(c, LLVMConstInt(LLVMInt8Type(), cast(i64, ch), 0), name, expression, codegen_create_node(c, node_type));
 	};
 	
 	if ((*expression).type == NODE_PRIMARY_EXPRESSION_STRING) {
@@ -528,7 +531,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		inner_type.data = cast(*void, inner_type_data);
 
 		let node_type_data = cast(*NODE_TYPE_POINTER_TYPE_DATA, arena_alloc((*c).arena, sizeof(NODE_TYPE_POINTER_TYPE_DATA)));
-		(*node_type_data).type = create_node(c, inner_type);
+		(*node_type_data).type = codegen_create_node(c, inner_type);
 		let node_type = Node{};
 		node_type.type = NODE_TYPE_POINTER_TYPE;
 		node_type.data = cast(*void, node_type_data);
@@ -538,7 +541,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		v.type = cast(LLVMTypeRef, null);
 		v.stack_level = cast(*i64, null);
 		v.node = expression;
-		v.node_type = create_node(c, node_type);
+		v.node_type = codegen_create_node(c, node_type);
 
 		return codegen_create_variable(c, v);
 	};
@@ -649,7 +652,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		(*d).parameters_len = i;
 		(*d).retur_type = function_definition.retur_type;
 		let n = Node{};
-		let node_type = create_node(c, n);
+		let node_type = codegen_create_node(c, n);
 		(*node_type).type = NODE_TYPE_FUNCTION_TYPE;
 		(*node_type).data = cast(*void, d);
 
@@ -762,9 +765,9 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 			LLVMAddIncoming(phi, fals_val, current_block, 1);
 			LLVMAddIncoming(phi, rhs_val, rhs_end_block, 1);
 
-			return codegen_generate_literal(c, phi, name, expression, create_node(c, node_type));
+			return codegen_generate_literal(c, phi, name, expression, codegen_create_node(c, node_type));
 		};
-		if !exp.an {
+		if !exp.an { /*TODO: Understand this */
 			let rhs_block = LLVMAppendBasicBlock((*c).current_function, "or_rhs");
 			let merge_block = LLVMAppendBasicBlock((*c).current_function, "or_merge");
 
@@ -796,7 +799,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 			LLVMAddIncoming(phi, tru_val, current_block, 1);
 			LLVMAddIncoming(phi, rhs_val, rhs_end_block, 1);
 
-			return codegen_generate_literal(c, phi, name, expression, create_node(c, node_type));
+			return codegen_generate_literal(c, phi, name, expression, codegen_create_node(c, node_type));
 		};
 
 		assert(false);
@@ -847,7 +850,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		(*d).underlying_type = cast(*Node, null);
 		node_type.data = cast(*void, d);
 
-		return codegen_generate_literal(c, cmp, name, expression, create_node(c, node_type));
+		return codegen_generate_literal(c, cmp, name, expression, codegen_create_node(c, node_type));
 	};
 	
 	if ((*expression).type == NODE_ADDITIVE_EXPRESSION) {
@@ -868,7 +871,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		(*d).underlying_type = cast(*Node, null);
 		node_type.data = cast(*void, d);
 
-		let pnode_type = create_node(c, node_type);
+		let pnode_type = codegen_create_node(c, node_type);
 
 		if exp.addition {
 			let nt = (*lhs_value).node_type;
@@ -938,7 +941,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 			(*d).name = "bool";
 			(*d).underlying_type = cast(*Node, null);
 			node_type.data = cast(*void, d);
-			typ = create_node(c, node_type);
+			typ = codegen_create_node(c, node_type);
 		};
 		
 		if exp.typ == UNARY_EXPRESSION_TYPE_MINUS {
@@ -950,7 +953,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 			(*d).name = "i64";
 			(*d).underlying_type = cast(*Node, null);
 			node_type.data = cast(*void, d);
-			typ = create_node(c, node_type);
+			typ = codegen_create_node(c, node_type);
 		};
 		
 		if exp.typ == UNARY_EXPRESSION_TYPE_STAR {
@@ -1023,7 +1026,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		v.type = cast(LLVMTypeRef, null);
 		v.stack_level = cast(*i64, null);
 		v.node = expression;
-		v.node_type = create_node(c, node_type);
+		v.node_type = codegen_create_node(c, node_type);
 		return codegen_create_variable(c, v);
 	};
 
@@ -1035,7 +1038,7 @@ let codegen_generate_expression_value = (c: *codegen, expression: *Node, name: *
 		let n = Node{};
 		n.type = NODE_TYPE_SIMPLE_TYPE;
 		n.data = cast(*void, dd);
-		let simple_type_node = create_node(c, n);
+		let simple_type_node = codegen_create_node(c, n);
 
 		let struc_type = LLVMStructCreateNamed((*c).llvm_context, name);
 
@@ -1308,10 +1311,10 @@ let codegen_generate_function_call_statement = (c: *codegen, statement: *Node) =
 		i = i + 1;
 	};
 
-	let function_type = codegen_get_llvm_type(c, (*function).node_type);
-	assert(function_type != cast(*LLVMTypeRef, null));
+	let llvm_function_type = codegen_get_llvm_type(c, (*function).node_type);
+	assert(llvm_function_type != cast(*LLVMTypeRef, null));
 
-	let res = LLVMBuildCall2((*c).builder, *function_type, (*function).value, arguments, i, "");
+	let res = LLVMBuildCall2((*c).builder, *llvm_function_type, (*function).value, arguments, i, "");
 
 	let function_return_type = get_function_return_type(c, (*function).node_type);
 
@@ -1347,6 +1350,8 @@ let codegen_generate_if_statement = (c: *codegen, statement: *NODE_IF_STATEMENT_
 	let then_block = LLVMAppendBasicBlock((*c).current_function, "then_block");
 	LLVMPositionBuilderAtEnd((*c).builder, then_block);
 
+	environment_create_scope((*c).environment);
+
 	let i = 0;
 	while i < (*statement).statements_len {
 		let stmt = (*((*statement).statements + cast(**Node, i)));
@@ -1354,6 +1359,8 @@ let codegen_generate_if_statement = (c: *codegen, statement: *NODE_IF_STATEMENT_
 		assert(res == 0);
 		i = i + 1;
 	};
+	
+	environment_drop_scope((*c).environment);
 
 	let merge_block = LLVMAppendBasicBlock((*c).current_function, "merge_block");
 	let last_instr = LLVMGetLastInstruction(LLVMGetInsertBlock((*c).builder));
@@ -1386,6 +1393,9 @@ let codegen_generate_while_statement = (c: *codegen, statement: *NODE_WHILE_STAT
 	(*c).whil_block = whil_block;
 	
 	LLVMPositionBuilderAtEnd((*c).builder, inner_block);
+
+	environment_create_scope((*c).environment);
+
 	let i = 0;
 	while i < (*statement).statements_len {
 		let stmt = (*((*statement).statements + cast(**Node, i)));
@@ -1394,6 +1404,8 @@ let codegen_generate_while_statement = (c: *codegen, statement: *NODE_WHILE_STAT
 		i = i + 1;
 	};
 	
+	environment_drop_scope((*c).environment);
+	
 	LLVMBuildBr((*c).builder, whil_block);
 	LLVMPositionBuilderAtEnd((*c).builder, outer_block);
 
diff --git a/src/parser.pry b/src/parser.pry
index 4d6b27a..bd2db37 100644
--- a/src/parser.pry
+++ b/src/parser.pry
@@ -243,7 +243,7 @@ let parser_init = (ts: *token, ts_len: i64, ar: *arena, filename: *i8) => *parse
 	return p;
 };
 
-let create_node = (p: *parser, n: Node) => *Node {
+let parser_create_node = (p: *parser, n: Node) => *Node {
 	let res = cast(*Node, arena_alloc((*p).arena, sizeof(Node)));
 	*res = n;
 	return res;
@@ -303,7 +303,7 @@ let parser_parse_return_statement = (p: *parser) => *Node {
 	r.type = NODE_RETURN_STATEMENT;
 	r.data = cast(*void, d);
 
-	return create_node(p, r);
+	return parser_create_node(p, r);
 };
 
 extern parser_parse_type = (*parser) => *Node;
@@ -349,7 +349,7 @@ let parser_parse_cast_statement = (p: *parser) => *Node {
 	r.type = NODE_CAST_STATEMENT;
 	r.data = cast(*void, d);
 
-	return create_node(p, r);
+	return parser_create_node(p, r);
 };
 
 /* SizeOfStatement ::= "sizeof" LPAREN TYPE RPAREN */
@@ -383,7 +383,7 @@ let parser_parse_sizeof_statement = (p: *parser) => *Node {
 	r.type = NODE_SIZEOF_STATEMENT;
 	r.data = cast(*void, d);
 
-	return create_node(p, r);
+	return parser_create_node(p, r);
 };
 
 /* FunctionType ::= LPAREN (Type ("," Type)*)? RPAREN ARROW Type */
@@ -430,7 +430,7 @@ let parser_parse_function_type = (p: *parser) => *Node {
 	r.type = NODE_TYPE_FUNCTION_TYPE;
 	r.data = cast(*void, d);
 
-	return create_node(p, r);
+	return parser_create_node(p, r);
 };
 
 /* Type ::= IDENTIFIER | FunctionType */
@@ -453,7 +453,7 @@ let parser_parse_type = (p: *parser) => *Node {
 		r.type = NODE_TYPE_SIMPLE_TYPE;
 		r.data = cast(*void, d);
 
-		return create_node(p, r);
+		return parser_create_node(p, r);
 	};
 
 	if (*to).type == TOKEN_MUL {
@@ -464,7 +464,7 @@ let parser_parse_type = (p: *parser) => *Node {
 		r.type = NODE_TYPE_POINTER_TYPE;
 		r.data = cast(*void, d);
 
-		return create_node(p, r);
+		return parser_create_node(p, r);
 	};
 
 	return cast(*Node, null);
@@ -509,7 +509,7 @@ let parser_parse_if_statement = (p: *parser) => *Node {
 	r.type = NODE_IF_STATEMENT;
 	r.data = cast(*void, dd);
 
-	return create_node(p, r);
+	return parser_create_node(p, r);
 };
 
 /* WhileStatement ::= "while" Expression LBRACE Statement* RBRACE */
@@ -551,7 +551,7 @@ let parser_parse_while_statement = (p: *parser) => *Node {
 	r.type = NODE_WHILE_STATEMENT;
 	r.data = cast(*void, dd);
 
-	return create_node(p, r);
+	return parser_create_node(p, r);
 };
 
 /* ExternDeclaration ::= "extern" IDENTIFIER EQUALS Type */
@@ -583,14 +583,14 @@ let parser_parse_extern_declaration = (p: *parser) => *Node {
 	let dd = cast(*NODE_ASSIGNMENT_STATEMENT_DATA, arena_alloc((*p).arena, sizeof(NODE_ASSIGNMENT_STATEMENT_DATA)));
 	(*dd).is_declaration = false;
 	(*dd).is_dereference = false;
-	(*dd).lhs = create_node(p, n);
+	(*dd).lhs = parser_create_node(p, n);
 	(*dd).rhs = typ;
 
 	let r = Node{};
 	r.type = NODE_ASSIGNMENT_STATEMENT;
 	r.data = cast(*void, dd);
 
-	return create_node(p, r);
+	return parser_create_node(p, r);
 };
 
 /* FunctionParameters ::= IDENTIFIER ":" Type ("," IDENTIFIER ":" Type)* */
@@ -619,7 +619,7 @@ let parser_parse_function_parameters = (p: *parser) => *slice {
 		let n = Node{};
 		n.type = NODE_PRIMARY_EXPRESSION_IDENTIFIER;
 		n.data = cast(*void, d);
-		(*(node_list + cast(**Node, i))) = create_node(p, n);
+		(*(node_list + cast(**Node, i))) = parser_create_node(p, n);
 
 		i = i + 1;
 	};
@@ -649,7 +649,7 @@ let parser_parse_type_definition = (p: *parser) => *Node {
 	r.type = NODE_TYPE_SIMPLE_TYPE;
 	r.data = cast(*void, d);
 
-	return create_node(p, r);
+	return parser_create_node(p, r);
 };
 
 /* StructDefinition ::= "struct" LBRACE StructFields? RBRACE */
@@ -683,7 +683,7 @@ let parser_parse_struct_definition = (p: *parser) => *Node {
 			let n = Node{};
 			n.type = NODE_PRIMARY_EXPRESSION_IDENTIFIER;
 			n.data = cast(*void, d);
-			return create_node(ip, n);
+			return parser_create_node(ip, n);
 		});
 		if field == cast(*Node, null) {
 			break;
@@ -705,7 +705,7 @@ let parser_parse_struct_definition = (p: *parser) => *Node {
 	let n = Node{};
 	n.type = NODE_TYPE_STRUCT_TYPE;
 	n.data = cast(*void, d);
-	return create_node(p, n);
+	return parser_create_node(p, n);
 };
 
 /* FunctionDefinition ::= LPAREN FunctionParameters? RPAREN ARROW IDENTIFIER LBRACE Statement* ReturnStatement SEMICOLON RBRACE */
@@ -767,7 +767,7 @@ let parser_parse_function_definition = (p: *parser) => *Node {
 	n.type = NODE_FUNCTION_DEFINITION;
 	n.data = cast(*void, d);
 
-	return create_node(p, n); 
+	return parser_create_node(p, n); 
 };
 
 /* StructInstantiation ::= IDENTIFIER LBRACE RBRACE */
@@ -791,7 +791,7 @@ let parser_parse_struct_instanciation = (p: *parser) => *Node {
 	n.type = NODE_STRUCT_INSTANCIATION;
 	n.data = cast(*void, d);
 
-	return create_node(p, n); 
+	return parser_create_node(p, n); 
 };
 
 extern parser_parse_primary_expression = (*parser) => *Node;
@@ -818,7 +818,7 @@ let parser_parse_field_access = (p: *parser) => *Node {
 	n.type = NODE_FIELD_ACCESS;
 	n.data = cast(*void, d);
 
-	return create_node(p, n); 
+	return parser_create_node(p, n); 
 };
 
 /* PrimaryExpression ::= NULL | NUMBER | BOOLEAN | CHAR | STRING | IDENTIFIER | FunctionDefinition | StructDefinition | StructInstantiation | FieldAccess | LPAREN Expression RPAREN */
@@ -860,7 +860,7 @@ let parser_parse_primary_expression = (p: *parser) => *Node {
 	if (*tok).type == TOKEN_NULL {
 	    let n = Node{};
 	    n.type = NODE_PRIMARY_EXPRESSION_NULL;
-	    return create_node(p, n);
+	    return parser_create_node(p, n);
 	};
 
 	if (*tok).type == TOKEN_IDENTIFIER {
@@ -870,7 +870,7 @@ let parser_parse_primary_expression = (p: *parser) => *Node {
 	    let n = Node{};
 	    n.type = NODE_PRIMARY_EXPRESSION_IDENTIFIER;
 	    n.data = cast(*void, d);
-	    return create_node(p, n);
+	    return parser_create_node(p, n);
 	};
 
 	if (*tok).type == TOKEN_NUMBER {
@@ -879,7 +879,7 @@ let parser_parse_primary_expression = (p: *parser) => *Node {
 	    let n = Node{};
 	    n.type = NODE_PRIMARY_EXPRESSION_NUMBER;
 	    n.data = cast(*void, d);
-	    return create_node(p, n);
+	    return parser_create_node(p, n);
 	};
 	
 	if (*tok).type == TOKEN_BOOLEAN {
@@ -888,7 +888,7 @@ let parser_parse_primary_expression = (p: *parser) => *Node {
 	    let n = Node{};
 	    n.type = NODE_PRIMARY_EXPRESSION_BOOLEAN;
 	    n.data = cast(*void, d);
-	    return create_node(p, n);
+	    return parser_create_node(p, n);
 	};
 	
 	if (*tok).type == TOKEN_CHAR {
@@ -897,7 +897,7 @@ let parser_parse_primary_expression = (p: *parser) => *Node {
 	    let n = Node{};
 	    n.type = NODE_PRIMARY_EXPRESSION_CHAR;
 	    n.data = cast(*void, d);
-	    return create_node(p, n);
+	    return parser_create_node(p, n);
 	};
 	
 	if (*tok).type == TOKEN_STRING {
@@ -906,7 +906,7 @@ let parser_parse_primary_expression = (p: *parser) => *Node {
 	    let n = Node{};
 	    n.type = NODE_PRIMARY_EXPRESSION_STRING;
 	    n.data = cast(*void, d);
-	    return create_node(p, n);
+	    return parser_create_node(p, n);
 	};
 
 	return cast(*Node, null);
@@ -929,7 +929,7 @@ let parser_parse_equality_expression = (p: *parser) => *Node {
 				return cast(*Node, null);
 			};
 			let n = Node{};
-			return create_node(ip, n);
+			return parser_create_node(ip, n);
 		});
 		if ex != cast(*Node, null) {
 			typ = EQUALITY_EXPRESSION_TYPE_EQ;
@@ -944,7 +944,7 @@ let parser_parse_equality_expression = (p: *parser) => *Node {
 					return cast(*Node, null);
 				};
 				let n = Node{};
-				return create_node(ip, n);
+				return parser_create_node(ip, n);
 			});
 			if (ex != cast(*Node, null)) {
 				typ = EQUALITY_EXPRESSION_TYPE_NE;
@@ -960,7 +960,7 @@ let parser_parse_equality_expression = (p: *parser) => *Node {
 					return cast(*Node, null);
 				};
 				let n = Node{};
-				return create_node(ip, n);
+				return parser_create_node(ip, n);
 			});
 			if (ex != cast(*Node, null)) {
 				typ = EQUALITY_EXPRESSION_TYPE_LE;
@@ -976,7 +976,7 @@ let parser_parse_equality_expression = (p: *parser) => *Node {
 					return cast(*Node, null);
 				};
 				let n = Node{};
-				return create_node(ip, n);
+				return parser_create_node(ip, n);
 			});
 			if (ex != cast(*Node, null)) {
 				typ = EQUALITY_EXPRESSION_TYPE_GE;
@@ -1009,7 +1009,7 @@ let parser_parse_equality_expression = (p: *parser) => *Node {
 		n.type = NODE_EQUALITY_EXPRESSION ;
 		n.data = cast(*void, d);
 
-		lhs = create_node(p, n);
+		lhs = parser_create_node(p, n);
 	};
 
 	return lhs; 
@@ -1062,7 +1062,7 @@ let parser_parse_unary_expression = (p: *parser) => *Node {
 	let new_lhs = Node{};
 	new_lhs.type = NODE_UNARY_EXPRESSION;
 	new_lhs.data = cast(*void, new_lhs_data);
-	return create_node(p, new_lhs);
+	return parser_create_node(p, new_lhs);
 };
 
 /* MultiplicativeExpression ::= UnaryExpression (("*" | "/" | "%") UnaryExpression)* */
@@ -1099,7 +1099,7 @@ let parser_parse_multiplicative_expression = (p: *parser) => *Node {
 		let new_lhs = Node{};
 		new_lhs.type = NODE_MULTIPLICATIVE_EXPRESSION;
 		new_lhs.data = cast(*void, new_lhs_data);
-		lhs = create_node(p, new_lhs);
+		lhs = parser_create_node(p, new_lhs);
 	};
 	return lhs;
 };
@@ -1131,7 +1131,7 @@ let parser_parse_additive_expression = (p: *parser) => *Node {
 		let new_lhs = Node{};
 		new_lhs.type = NODE_ADDITIVE_EXPRESSION;
 		new_lhs.data = cast(*void, new_lhs_data);
-		lhs = create_node(p, new_lhs);
+		lhs = parser_create_node(p, new_lhs);
 	};
 	return lhs;
 };
@@ -1163,7 +1163,7 @@ let parser_parse_logical_expression = (p: *parser) => *Node {
 		let new_lhs = Node{};
 		new_lhs.type = NODE_LOGICAL_EXPRESSION;
 		new_lhs.data = cast(*void, new_lhs_data);
-		lhs = create_node(p, new_lhs);
+		lhs = parser_create_node(p, new_lhs);
 	};
 	return lhs;
 };
@@ -1207,7 +1207,7 @@ let parse_assignment_statement = (p: *parser) => *Node {
 	let n = Node{};
 	n.type = NODE_ASSIGNMENT_STATEMENT;
 	n.data = cast(*void, d);
-	return create_node(p, n);
+	return parser_create_node(p, n);
 };
 
 extern parse = (*parser) => *Node;
@@ -1272,7 +1272,7 @@ let parser_parse_import_declaration = (p: *parser) => *Node {
 	let n = Node{};
 	n.type = NODE_IMPORT_DECLARATION;
 	n.data = cast(*void, d);
-	return create_node(p, n);
+	return parser_create_node(p, n);
 };
 
 /* FunctionArguments ::= Expression ("," Expression)* */
@@ -1347,7 +1347,7 @@ let parse_function_call_statement = (p: *parser) => *Node {
 	let n = Node{};
 	n.type = NODE_FUNCTION_CALL_STATEMENT;
 	n.data = cast(*void, d);
-	return create_node(p, n);
+	return parser_create_node(p, n);
 };
 
 /* Statement    ::= (AssignmentStatement | ImportDeclaration | ExternDeclaration | CastStatement | SizeOfStatement | FunctionCallStatement | IfStatement | WhileStatement | ReturnStatement | "break" | "continue") SEMICOLON */
@@ -1433,7 +1433,7 @@ let parser_parse_statement = (p: *parser) => *Node {
 		
 		let n = Node{};
 		n.type = NODE_BREAK_STATEMENT;
-		return create_node(ip, n);
+		return parser_create_node(ip, n);
 	});
 	if retu != cast(*Node, null) {
 		if parser_accept_token(p, TOKEN_SEMICOLON) == cast(*token, null) {
@@ -1449,7 +1449,7 @@ let parser_parse_statement = (p: *parser) => *Node {
 		
 		let n = Node{};
 		n.type = NODE_CONTINUE_STATEMENT;
-		return create_node(ip, n);
+		return parser_create_node(ip, n);
 	});
 	if retu != cast(*Node, null) {
 		if parser_accept_token(p, TOKEN_SEMICOLON) == cast(*token, null) {
@@ -1481,7 +1481,7 @@ let parse_program = (p: *parser) => *Node {
 	let n = Node{};
 	n.type = NODE_PROGRAM;
 	n.data = cast(*void, d);
-	return create_node(p, n);
+	return parser_create_node(p, n);
 };
 
 let parse = (p: *parser) => *Node {