Improve minimal dependency system

1 files changed, 83 insertions, 5 deletions

diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 139b376f2..8bdb23658 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -1561,9 +1561,38 @@ void check_comparison(Checker *c, Operand *x, Operand *y, TokenKind op) {
 		} else {
 			x->mode = Addressing_Value;
 
-
 			update_expr_type(c, x->expr, default_type(x->type), true);
 			update_expr_type(c, y->expr, default_type(y->type), true);
+
+			i64 size = 0;
+			if (!is_type_untyped(x->type)) size = gb_max(size, type_size_of(x->type));
+			if (!is_type_untyped(y->type)) size = gb_max(size, type_size_of(y->type));
+
+			if (is_type_string(x->type) || is_type_string(y->type)) {
+				switch (op) {
+				case Token_CmpEq: add_preload_dependency(c, "__string_eq"); break;
+				case Token_NotEq: add_preload_dependency(c, "__string_ne"); break;
+				case Token_Lt:    add_preload_dependency(c, "__string_lt"); break;
+				case Token_Gt:    add_preload_dependency(c, "__string_gt"); break;
+				case Token_LtEq:  add_preload_dependency(c, "__string_le"); break;
+				case Token_GtEq:  add_preload_dependency(c, "__string_gt"); break;
+				}
+			} else if (is_type_complex(x->type) || is_type_complex(y->type)) {
+				switch (op) {
+				case Token_CmpEq:
+					switch (8*size) {
+					case 64:  add_preload_dependency(c, "__complex64_eq");  break;
+					case 128: add_preload_dependency(c, "__complex128_eq"); break;
+					}
+					break;
+				case Token_NotEq:
+					switch (8*size) {
+					case 64:  add_preload_dependency(c, "__complex64_ne");  break;
+					case 128: add_preload_dependency(c, "__complex128_ne"); break;
+					}
+					break;
+				}
+			}
 		}
 
 		x->type = t_untyped_bool;
@@ -1820,6 +1849,9 @@ bool check_is_castable_to(Checker *c, Operand *operand, Type *y) {
 	}
 	// cstring -> string
 	if (src == t_cstring && dst == t_string) {
+		if (operand->mode != Addressing_Constant) {
+			add_preload_dependency(c, "__cstring_to_string");
+		}
 		return true;
 	}
 	// cstring -> ^u8
@@ -2878,6 +2910,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 			operand->type = t_source_code_location;
 			operand->mode = Addressing_Value;
+			add_preload_dependency(c, "make_source_code_location");
 		} else if (name == "assert") {
 			if (ce->args.count != 1) {
 				error(call, "'#assert' expects at 1 argument, got %td", ce->args.count);
@@ -2920,6 +2953,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 				type = t_untyped_integer;
 			} else {
 				mode = Addressing_Value;
+				if (is_type_cstring(op_type)) {
+					add_preload_dependency(c, "__cstring_len");
+				}
 			}
 		} else if (is_type_array(op_type)) {
 			Type *at = core_type(op_type);
@@ -3021,12 +3057,15 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		if (is_type_slice(type)) {
 			min_args = 2;
 			max_args = 2;
+			add_preload_dependency(c, "alloc");
 		} else if (is_type_map(type)) {
 			min_args = 1;
 			max_args = 2;
+			add_preload_dependency(c, "__dynamic_map_reserve");
 		} else if (is_type_dynamic_array(type)) {
 			min_args = 1;
 			max_args = 3;
+			add_preload_dependency(c, "__dynamic_array_make");
 		} else {
 			gbString str = type_to_string(type);
 			error(call, "Cannot 'make' %s; type must be a slice, map, or dynamic array", str);
@@ -3723,6 +3762,13 @@ break;
 				gb_string_free(type_a);
 				return false;
 			}
+
+			{
+				Type *bt = base_type(a.type);
+				if (bt == t_f32) add_preload_dependency(c, "__min_f32");
+				if (bt == t_f64) add_preload_dependency(c, "__min_f64");
+			}
+
 		}
 
 
@@ -3793,6 +3839,12 @@ break;
 				gb_string_free(type_a);
 				return false;
 			}
+
+			{
+				Type *bt = base_type(a.type);
+				if (bt == t_f32) add_preload_dependency(c, "__max_f32");
+				if (bt == t_f64) add_preload_dependency(c, "__max_f64");
+			}
 		}
 
 
@@ -3829,6 +3881,14 @@ break;
 			}
 		} else {
 			operand->mode = Addressing_Value;
+
+			{
+				Type *bt = base_type(operand->type);
+				if (bt == t_f32)        add_preload_dependency(c, "__abs_f32");
+				if (bt == t_f64)        add_preload_dependency(c, "__abs_f64");
+				if (bt == t_complex64)  add_preload_dependency(c, "__abs_complex64");
+				if (bt == t_complex128) add_preload_dependency(c, "__abs_complex128");
+			}
 		}
 
 		if (is_type_complex(operand->type)) {
@@ -3924,6 +3984,18 @@ break;
 				gb_string_free(type_x);
 				return false;
 			}
+
+			{
+				Type *bt = base_type(x.type);
+				if (bt == t_f32) {
+					add_preload_dependency(c, "__min_f32");
+					add_preload_dependency(c, "__max_f32");
+				}
+				if (bt == t_f64) {
+					add_preload_dependency(c, "__min_f64");
+					add_preload_dependency(c, "__max_f64");
+				}
+			}
 		}
 
 		break;
@@ -5149,10 +5221,6 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 			o->mode       = Addressing_Builtin;
 			o->builtin_id = BuiltinProc_type_of;
 			break;
-		case Token_type_info_of:
-			o->mode       = Addressing_Builtin;
-			o->builtin_id = BuiltinProc_type_info_of;
-			break;
 
 		default:
 			error(node, "Illegal implicit name '%.*s'", LIT(i->string));
@@ -5534,6 +5602,9 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 				elem_type = t->DynamicArray.elem;
 				context_name = str_lit("dynamic array literal");
 				is_constant = false;
+
+				add_preload_dependency(c, "__dynamic_array_reserve");
+				add_preload_dependency(c, "__dynamic_array_append");
 			} else {
 				GB_PANIC("unreachable");
 			}
@@ -5692,6 +5763,8 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 				}
 			}
 
+			add_preload_dependency(c, "__dynamic_map_reserve");
+			add_preload_dependency(c, "__dynamic_map_set");
 			break;
 		}
 
@@ -5813,6 +5886,8 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 			o->expr = node;
 			return kind;
 		}
+
+		add_preload_dependency(c, "__type_assertion_check");
 	case_end;
 
 	case_ast_node(tc, TypeCast, node);
@@ -5911,6 +5986,9 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 			o->mode = Addressing_MapIndex;
 			o->type = t->Map.value;
 			o->expr = node;
+
+			add_preload_dependency(c, "__dynamic_map_get");
+			add_preload_dependency(c, "__dynamic_map_set");
 			return Expr_Expr;
 		}