compiler: refactor anytype '#' handling

struct Type now has a property 'bool is_anytype' to represent the
anytype.

Anytype can be used to override the typechecker. For example, calling a
memory allocation function returns a pointer, which can be a used as a
pointer to any other type, whatever is put there.

Anytype should have the highest native width of the architecture which
is targeted, so 8 bytes for x86-64, and 2 bytes for AVR.

Author: pointbazaar

ast/ast/ast_types.h

@@ -69,6 +69,11 @@ struct Type {
 	struct TypeParam* type_param;
 	struct ArrayType* array_type;
 	struct PointerType* pointer_type;
+
+	// '#', stands for anything,
+	// always has highest native width of the architecture,
+	// e.g. x86: 8 bytes, avr: 2 bytes
+	bool is_anytype;
 };
 
 struct TypeParam {

ast/test/test_str_ast.c

@@ -104,7 +104,7 @@ void test_ast_str_expr() {
 
 	char* s = str_expr(&e);
 
-	assert(strcmp(s, "-45*-45") == 0);
+	assert(strcmp(s, "-45 * -45") == 0);
 
 	free_un_op_term(u2);
 	free(s);

ast/util/copy_ast.c

@@ -179,6 +179,7 @@ struct Type* copy_type(struct Type* t) {
 	res->type_param = NULL;
 	res->array_type = NULL;
 	res->pointer_type = NULL;
+	res->is_anytype = t->is_anytype;
 
 	if (t->basic_type != NULL) { res->basic_type = copy_basic_type(t->basic_type); }
 	if (t->type_param != NULL) { res->type_param = copy_type_param(t->type_param); }

ast/util/equals_ast.c

@@ -17,6 +17,10 @@ bool eq_type(struct Type* a, struct Type* b) {
 
 	if (a->pointer_type != NULL) { return eq_pointertype(a->pointer_type, b->pointer_type); }
 
+	if (a->is_anytype && b->is_anytype) {
+		return true;
+	}
+
 	return false;
 }
 

ast/util/str_ast.c

@@ -293,6 +293,10 @@ char* str_type(struct Type* t) {
 
 	if (t->pointer_type != NULL) { return str_pointer_type(t->pointer_type); }
 
+	if (t->is_anytype) {
+		return strdup("#");
+	}
+
 	error("str_type");
 	return NULL;
 }
@@ -494,15 +498,15 @@ char* str_expr(struct Expr* e) {
 		return NULL;
 	}
 
-	uint16_t l = strlen(strTerm1) + strlen(strO) + strlen(strTerm2) + 1;
+	uint16_t l = strlen(strTerm1) + strlen(strO) + strlen(strTerm2) + 3;
 
 	char* res = malloc(sizeof(char) * l);
 
 	if (!res) {
 		return NULL;
 	}
 
-	sprintf(res, "%s%s%s", strTerm1, strO, strTerm2);
+	sprintf(res, "%s %s %s", strTerm1, strO, strTerm2);
 
 	free(strTerm1);
 
@@ -512,6 +516,7 @@ char* str_expr(struct Expr* e) {
 	return res;
 }
 
+// @returns NULL on error
 char* str_op(enum OP o) {
 
 	char* res = malloc(sizeof(char) * 16);
@@ -533,8 +538,18 @@ char* str_op(enum OP o) {
 		case OP_OR: str = "|"; break;
 		case OP_XOR: str = "^"; break;
 
+		// relational
+		case OP_EQ: str = "=="; break;
+		case OP_NEQ: str = "!="; break;
+		case OP_GE: str = ">="; break;
+		case OP_GT: str = ">"; break;
+		case OP_LE: str = "<="; break;
+		case OP_LT: str = "<"; break;
+
 		//should not happen
-		default: str = "fix str_op"; break;
+		default:
+			free(res);
+			return NULL;
 	}
 
 	sprintf(res, "%s", str);

compiler/main/typechecker/tc_ifstmt.c

@@ -35,6 +35,12 @@ bool tc_ifstmt(struct IfStmt* i, struct TCCtx* tcctx) {
 
 		error_snippet(tcctx, msg, TC_ERR_CONDITION_REQUIRES_BOOL);
 
+		char* s2 = str_type(type);
+
+		fprintf(stderr, "actual type: %s\n\n", s2);
+
+		free(s2);
+
 		free(msg);
 
 		return false;

compiler/main/typechecker/tc_retstmt.c

@@ -11,6 +11,7 @@
 
 //Typechecker Includes
 #include "_tc.h"
+#include "typechecker/type_contains/tc_type_contains.h"
 #include "typechecker/util/tc_errors.h"
 #include "typechecker/util/tc_utils.h"
 #include "tcctx.h"
@@ -31,7 +32,7 @@ bool tc_retstmt(struct RetStmt* r, struct TCCtx* tcctx) {
 
 	if (is_integer_type(returnType) && is_integer_type(returnedType)) { return true; }
 
-	if (!eq_type(returnType, returnedType)) {
+	if (!tc_type_contains(returnType, returnedType)) {
 
 		char* s1 = str_type(returnType);
 		char* s2 = str_type(returnedType);

compiler/main/typechecker/type_contains/tc_pointertype_contains.c

@@ -22,5 +22,5 @@ bool tc_pointer_type_contains(struct PointerType* expect, struct Type* actual) {
 	struct PointerType* apt = actual->pointer_type;
 
 	// pointers of same underlying type can be assigned to each other
-	return eq_type(expect->element_type, apt->element_type);
+	return tc_type_contains(expect->element_type, apt->element_type);
 }

compiler/main/typechecker/type_contains/tc_type_contains.c

@@ -9,6 +9,10 @@
 
 bool tc_type_contains(struct Type* expect, struct Type* actual) {
 
+	if (expect->is_anytype || actual->is_anytype) {
+		return true;
+	}
+
 	if (expect->pointer_type != NULL) {
 
 		return tc_pointer_type_contains(expect->pointer_type, actual);

compiler/main/typeinference/typeinfer_expr.c

@@ -21,7 +21,7 @@ static struct Type* infer_type_expr_primitive(struct ST* st, struct Expr2Types*
 
 static struct Type* infer_type_expr_both_tparam(struct ST* st, struct TypeParam* tp1, enum OP op, struct TypeParam* tp2);
 
-static struct Type* infer_type_expr_ptr_arithmetic(struct ST* st, struct Type* t1, struct Type* t2);
+static struct Type* infer_type_expr_ptr_arithmetic(struct ST* st, struct Type* t1, struct Type* t2, enum OP op);
 
 static void typeinfer_err_fatal(char* opt_str) {
 	fprintf(stderr, "%s\n", opt_str);
@@ -44,10 +44,10 @@ struct Type* infer_type_expr(struct ST* st, struct Expr* expr) {
 	}
 
 	if (type1->pointer_type) {
-		return infer_type_expr_ptr_arithmetic(st, type1, type2);
+		return infer_type_expr_ptr_arithmetic(st, type1, type2, op);
 	}
 	if (type2->pointer_type) {
-		return infer_type_expr_ptr_arithmetic(st, type2, type1);
+		return infer_type_expr_ptr_arithmetic(st, type2, type1, op);
 	}
 
 	struct BasicType* btw1 = type1->basic_type;
@@ -82,7 +82,7 @@ struct Type* infer_type_expr(struct ST* st, struct Expr* expr) {
 	return infer_type_expr_primitive(st, &e2t);
 }
 
-static struct Type* infer_type_expr_ptr_arithmetic(struct ST* st, struct Type* t1, struct Type* t2) {
+static struct Type* infer_type_expr_ptr_arithmetic(struct ST* st, struct Type* t1, struct Type* t2, enum OP op) {
 
 	struct PointerType* pt = t1->pointer_type;
 
@@ -92,9 +92,15 @@ static struct Type* infer_type_expr_ptr_arithmetic(struct ST* st, struct Type* t
 	}
 
 	if (t2->basic_type && t2->basic_type->simple_type) {
-		struct SimpleType* st = t2->basic_type->simple_type;
+		struct SimpleType* stype = t2->basic_type->simple_type;
+
+		if (stype->primitive_type && stype->primitive_type->is_int_type) {
+
+			if (op == OP_EQ || op == OP_NEQ || op == OP_GE || op == OP_GT || op == OP_LE || op == OP_LT) {
+
+				return typeFromStrPrimitive(st, "bool");
+			}
 
-		if (st->primitive_type && st->primitive_type->is_int_type) {
 			return t1;
 		}
 	}