1 files changed, 484 insertions, 40 deletions

diff --git a/src/analyze.c b/src/analyze.c
index be52bfb..4f98ac6 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -3,7 +3,9 @@
 
 #include <fwd/compiler.h>
 #include <fwd/analyze.h>
+#include <fwd/rewrite.h>
 #include <fwd/mod.h>
+
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
@@ -214,16 +216,36 @@ static int analyze_init(struct state *state, struct scope *scope,
 	if (analyze(state, scope, init_body(node)))
 		return -1;
 
-	/** @todo check that all parameters match, though that requires that the
-	 * type is defined in fwd and not in C++, so this might have to wait a
-	 * bit */
-	node->t = tgen_construct(strdup(init_id(node)), init_args(node),
-	                         node->loc);
-	if (!node->t) {
-		internal_error("failed allocating type for construct");
+	internal_error("init unimplemented");
+	return -1;
+}
+
+static int deduce_closure_types(struct scope *scope, struct ast *node, struct type *type)
+{
+	/* a bit of checking duplication here, hmm */
+	if (node->k != AST_CLOSURE)
+		return 0;
+
+	if (type->k != TYPE_CLOSURE && type->k != TYPE_PURE_CLOSURE) {
+		semantic_error(scope, node, "surprise closure");
+		return -1;
+	}
+
+	struct ast *param = closure_bindings(node);
+	struct type *t = tclosure_args(type);
+	if (ast_list_len(param) != type_list_len(t)) {
+		semantic_error(scope, node, "expected %zu closure parameters, got %zu",
+				type_list_len(t), ast_list_len(param));
 		return -1;
 	}
 
+	for (; param && t; param = param->n, t = t->n) {
+		if (var_type(param))
+			continue;
+
+		var_type(param) = t;
+	}
+
 	return 0;
 }
 
@@ -241,8 +263,6 @@ static int analyze_call(struct state *state, struct scope *scope,
 
 	struct type *types = callable_types(expr->t);
 	struct ast *args = call_args(node);
-	if (analyze_list(state, scope, args))
-		return -1;
 
 	size_t expected = type_list_len(types);
 	size_t got = ast_list_len(args);
@@ -253,18 +273,24 @@ static int analyze_call(struct state *state, struct scope *scope,
 	}
 
 	struct type *type = types;
-	foreach_node(arg, args) {
+	struct ast *arg = args;
+	for (; arg && type; type = type->n, arg = arg->n) {
+		if (deduce_closure_types(scope, arg, type))
+			return -1;
+
+		if (analyze(state, scope, arg))
+			return -1;
+
 		if (arg->k == AST_CLOSURE)
 			state->flags |= STATE_PROC_REQ_FRAME;
 
 		if (!types_match(type, arg->t)) {
-			type_mismatch(scope, node, type, arg->t);
+			type_mismatch(scope, arg, type, arg->t);
 			return -1;
 		}
 
 		/* clone group info */
 		arg->t->group = type->group;
-		type = type->n;
 	}
 
 	node->t = tgen_void(node->loc);
@@ -309,7 +335,7 @@ static int analyze_deref(struct state *state, struct scope *scope,
 		semantic_error(node->scope, node,
 		               "deref of raw ptr not allowed");
 		semantic_info(node->scope, node,
-		              "use fwd_null() to convert to ref");
+		              "use a nil check to convert to ref");
 		return -1;
 	}
 
@@ -319,7 +345,7 @@ static int analyze_deref(struct state *state, struct scope *scope,
 		return -1;
 	}
 
-	node->t = tptr_base(expr->t);
+	node->t = tref_base(expr->t);
 	return 0;
 }
 
@@ -432,6 +458,126 @@ static int analyze_str(struct state *state, struct scope *scope,
 	return 0;
 }
 
+static int analyze_template(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct scope *template_scope = create_scope();
+	scope_add_scope(scope, template_scope);
+
+	/* enough for vec example since traits are as of yet unimplemented */
+
+	node->t = tgen_void(node->loc);
+	return 0;
+}
+
+static int analyze_instance(struct state *state, struct scope *scope, struct ast *node)
+{
+	(void)state;
+
+	struct ast *id = instance_templ(node);
+	struct ast *template = file_scope_find_template(scope, id_str(id));
+	if (!template) {
+		semantic_error(scope, node, "no such template: %s\n", id_str(id));
+		return -1;
+	}
+
+	/** @todo check that type implements trait */
+	struct ast *params = template_type_params(template);
+	struct type *args = instance_type_args(node);
+	if (ast_list_len(params) != type_list_len(args)) {
+		semantic_error(scope, node, "expected %zu types, got %zu\n",
+				ast_list_len(params), type_list_len(args));
+		return -1;
+	}
+
+	/* make a working copy that we modify */
+	struct ast *copy = clone_ast(template);
+	if (!copy) {
+		internal_error("failed copying template body");
+		return -1;
+	}
+
+	if (rewrite_holes(copy, instance_id(node)))
+		return -1;
+
+	/* replace type args */
+	struct ast *p = params;
+	struct type *a = args;
+	for (; p && a; p = p->n, a = a->n) {
+		if (rewrite_types(copy, var_id(p), tid_str(a)))
+			return -1;
+	}
+
+	printf("// --- instance %s ---\n", instance_id(node));
+	ast_dump(0, copy);
+
+	/* analyze newly initialized things (might not work for supertemplates?) */
+	if (analyze_root(scope, template_body(copy)))
+		return -1;
+
+	node->t = tgen_void(node->loc);
+	return 0;
+}
+
+static int analyze_struct(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct scope *struct_scope = create_scope();
+	scope_add_scope(scope, struct_scope);
+	node->scope = struct_scope;
+
+	if (analyze_list(state, struct_scope, struct_body(node)))
+		return -1;
+
+	node->t = tgen_void(node->loc);
+	return 0;
+}
+
+static int analyze_construct(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct ast *def = file_scope_find_type(scope, construct_id(node));
+	if (!def) {
+		semantic_error(scope, node, "no such type");
+		return -1;
+	}
+
+	if (def->k != AST_STRUCT_DEF) {
+		semantic_error(scope, node, "type is not a struct");
+		return -1;
+	}
+
+	struct ast *params = struct_body(def);
+	struct ast *args = construct_members(node);
+
+	if (ast_list_len(params) != ast_list_len(args)) {
+		semantic_error(scope, node, "expected %zu args, got %zu\n",
+				ast_list_len(params), ast_list_len(args));
+		return -1;
+	}
+
+	foreach_node(arg, args) {
+		struct ast *exists = scope_find_symbol(def->scope, construction_id(arg));
+		if (!exists) {
+			semantic_error(scope, arg, "no member %s in %s\n",
+					construction_id(arg), construct_id(node));
+			return -1;
+		}
+
+		struct ast *expr = construction_expr(arg);
+		if (analyze(state, scope, expr))
+			return -1;
+
+		if (!types_match(exists->t, expr->t)) {
+			type_mismatch(scope, arg, exists->t, expr->t);
+			return -1;
+		}
+
+		/** @todo check for duplicates, preferably not in O(n^2) or with
+		 * a memory allocation? */
+	}
+
+	node->t = tgen_id(strdup(construct_id(node)), node->loc);
+	return 0;
+}
+
 static int analyze_if(struct state *state, struct scope *scope,
                       struct ast *node)
 {
@@ -453,6 +599,212 @@ static int analyze_if(struct state *state, struct scope *scope,
 	return 0;
 }
 
+static int analyze_nil(struct state *state, struct scope *scope, struct ast *node)
+{
+	(void)state;
+	(void)scope;
+
+	node->t = tgen_nil(node->loc);
+	return 0;
+}
+
+static bool castable_type(struct type *type)
+{
+	switch (type->k) {
+	case TYPE_PTR:
+	case TYPE_FUNC_PTR:
+	case TYPE_I8:
+	case TYPE_I16:
+	case TYPE_I32:
+	case TYPE_I64:
+	case TYPE_U8:
+	case TYPE_U16:
+	case TYPE_U32:
+	case TYPE_U64:
+		return true;
+
+	default:
+		return false;
+	}
+
+	return false;
+}
+
+static int analyze_as(struct state *state, struct scope *scope, struct ast *node)
+{
+	if (analyze(state, scope, as_expr(node)))
+		return -1;
+
+	if (analyze_type(state, scope, as_type(node)))
+		return -1;
+
+	/* for now, any 'register' size type can be cast to any other. Might
+	 * restrict this, like signed to unsigned might be weird if its negative
+	 * etc and should be done via a helper function */
+	struct type *expr_type = (as_expr(node))->t;
+	struct type *type = as_type(node);
+	if (!castable_type(expr_type)) {
+		char *s = type_str(expr_type);
+		semantic_error(scope, as_expr(node), "can't cast from %s\n", s);
+		free(s);
+		return -1;
+	}
+
+	if (!castable_type(type)) {
+		char *s = type_str(type);
+		type_error(scope, type, "can't cast to %s\n", s);
+		free(s);
+		return -1;
+	}
+
+	node->t = type;
+	return 0;
+}
+
+static int analyze_assign(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct ast *expr = assign_expr(node);
+	if (analyze(state, scope, expr))
+		return -1;
+
+	struct ast *target = assign_target(node);
+	if (analyze(state, scope, target))
+		return -1;
+
+
+	if (!types_match(expr->t, target->t)) {
+		type_mismatch(scope, node, target->t, expr->t);
+		return -1;
+	}
+
+	if (!is_lvalue(target)) {
+		semantic_error(scope, target, "not an lvalue");
+		return -1;
+	}
+
+	node->t = target->t;
+	return 0;
+}
+
+static int analyze_dot(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct ast *expr = dot_expr(node);
+	if (analyze(state, scope, expr))
+		return -1;
+
+	struct type *type = expr->t;
+	if (type->k != TYPE_ID) {
+		char *s = type_str(type);
+		semantic_error(scope, node, "type %s does not have any members", s);
+		free(s);
+		return -1;
+	}
+
+	struct ast *def = file_scope_find_type(scope, tid_str(type));
+	if (!def) {
+		semantic_error(scope, node, "no such type: %s", tid_str(type));
+		return -1;
+	}
+
+	if (def->k != AST_STRUCT_DEF) {
+		semantic_error(scope, node, "not a struct type: %s", tid_str(type));
+		return -1;
+	}
+
+	struct ast *member = scope_find_symbol(def->scope, dot_id(node));
+	if (!member) {
+		semantic_error(scope, node, "no such member: %s", dot_id(node));
+		return -1;
+	}
+
+	node->t = member->t;
+	return 0;
+}
+
+static int analyze_sizeof(struct state *state, struct scope *scope, struct ast *node)
+{
+	if (analyze_type(state, scope, sizeof_type(node)))
+		return -1;
+
+	/* hmm, no built-in size_t */
+	node->t = tgen_type(TYPE_U64, NULL, NULL, node->loc);
+	return 0;
+}
+
+static int analyze_arr(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct ast *base = arr_base(node);
+	if (analyze(state, scope, base))
+		return -1;
+
+	if (base->t->k != TYPE_ARR) {
+		char *s = type_str(base->t);
+		semantic_error(scope, base, "expected array type, got %s", s);
+		free(s);
+		return -1;
+	}
+
+	struct ast *idx = arr_idx(node);
+	if (analyze(state, scope, idx))
+		return -1;
+
+	if (!is_int_type(idx->t->k)) {
+		char *s = type_str(idx->t);
+		semantic_error(scope, idx, "expected int type, got %s", s);
+		free(s);
+		return -1;
+	}
+
+	node->t = tarr_base(base->t);
+	return 0;
+}
+
+static int analyze_nil_check(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct ast *expr = nil_check_expr(node);
+	if (analyze(state, scope, expr))
+		return -1;
+
+	if (!is_ptr_type(expr->t->k)) {
+		char *s = type_str(expr->t);
+		semantic_error(scope, expr, "expected ptr type, got %s", s);
+		free(s);
+		return -1;
+	}
+
+	if (analyze(state, scope, nil_check_body(node)))
+		return -1;
+
+	struct ast *var = nil_check_ref(node);
+	struct type *base = tptr_base(expr->t);
+	struct type *ref = tgen_ref(clone_type(base), node->loc);
+	if (!var_type(var))
+		var_type(var) = ref;
+
+	if (analyze(state, scope, var))
+		return -1;
+
+	if (!types_match(ref, var->t)) {
+		type_mismatch(scope, var, ref, var->t);
+		return -1;
+	}
+
+	node->t = tgen_void(node->loc);
+	return 0;
+}
+
+static int analyze_forget(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct ast *def = file_scope_find_symbol(scope, forget_id(node));
+	if (!def) {
+		semantic_error(scope, node, "no such symbol");
+		return -1;
+	}
+
+	node->t = tgen_void(node->loc);
+	return 0;
+}
+
 static int analyze(struct state *state, struct scope *scope, struct ast *node)
 {
 	if (!node)
@@ -502,9 +854,32 @@ static int analyze(struct state *state, struct scope *scope, struct ast *node)
 	case AST_ID: ret = analyze_id(state, scope, node); break;
 	case AST_IF: ret = analyze_if(state, scope, node); break;
 
+	case AST_NIL_CHECK: ret = analyze_nil_check(state, scope, node); break;
+
 	case AST_CONST_INT: ret = analyze_int(state, scope, node); break;
 	case AST_CONST_STR: ret = analyze_str(state, scope, node); break;
 
+	case AST_INSTANCE: ret = analyze_instance(state, scope, node); break;
+	case AST_TEMPLATE: ret = analyze_template(state, scope, node); break;
+
+	case AST_STRUCT_DEF: ret = analyze_struct(state, scope, node); break;
+	case AST_CONSTRUCT: ret = analyze_construct(state, scope, node); break;
+
+	case AST_SIZEOF: ret = analyze_sizeof(state, scope, node); break;
+	case AST_NIL: ret = analyze_nil(state, scope, node); break;
+	case AST_AS: ret = analyze_as(state, scope, node); break;
+
+	case AST_ASSIGN: ret = analyze_assign(state, scope, node); break;
+	case AST_ARR: ret = analyze_arr(state, scope, node); break;
+	case AST_DOT: ret = analyze_dot(state, scope, node); break;
+
+	case AST_FORGET: ret = analyze_forget(state, scope, node); break;
+
+	case AST_TRAIT_DEF:
+		node->t = tgen_void(node->loc);
+		ret = 0;
+		break;
+
 	case AST_EMPTY:
 		node->t = tgen_void(node->loc);
 		ret = 0;
@@ -548,39 +923,61 @@ static int analyze_type(struct state *state, struct scope *scope,
 		return -1;
 
 	/* temporary */
-	if (type->k != TYPE_ID)
+	if (!type->id)
 		return 0;
 
 	char *id = type->id;
 
-	if (strcmp(id, "i8") == 0)
+	/* handle primitives */
+	if (strcmp(id, "i8") == 0) {
 		type->k = TYPE_I8;
+		return 0;
+	}
 
-	else if (strcmp(id, "u8") == 0)
+	if (strcmp(id, "u8") == 0) {
 		type->k = TYPE_U8;
+		return 0;
+	}
 
-	else if (strcmp(id, "i16") == 0)
+	if (strcmp(id, "i16") == 0) {
 		type->k = TYPE_I16;
+		return 0;
+	}
 
-	else if (strcmp(id, "u16") == 0)
+	if (strcmp(id, "u16") == 0) {
 		type->k = TYPE_U16;
+		return 0;
+	}
 
-	else if (strcmp(id, "i32") == 0)
+	if (strcmp(id, "i32") == 0) {
 		type->k = TYPE_I32;
+		return 0;
+	}
 
-	else if (strcmp(id, "u32") == 0)
+	if (strcmp(id, "u32") == 0) {
 		type->k = TYPE_U32;
+		return 0;
+	}
 
-	else if (strcmp(id, "i64") == 0)
+	if (strcmp(id, "i64") == 0) {
 		type->k = TYPE_I64;
+		return 0;
+	}
 
-	else if (strcmp(id, "u64") == 0)
+	if (strcmp(id, "u64") == 0) {
 		type->k = TYPE_U64;
-	else {
-		internal_error("unhandled type id: %s", id);
-		abort();
+		return 0;
 	}
 
+	/* check for user-defined types */
+	struct ast *def = file_scope_find_type(scope, id);
+	if (!def) {
+		type_error(scope, type, "no such type: %s", id);
+		return -1;
+	}
+
+	/* don't change type->k since we might want to check up on this again
+	 * later */
 	return 0;
 }
 
@@ -609,27 +1006,39 @@ static int copy_scope(bool reexport, struct scope *to, struct scope *from)
 			return -1;
 	}
 
-	foreach(visible, symbol, &from->types) {
-		struct ast *def = symbol->data;
+	foreach(visible, type, &from->types) {
+		struct ast *def = type->data;
 		if (!reexport && def->scope != from)
 			continue;
 
 		if (!ast_flags(def, AST_FLAG_PUBLIC))
 			continue;
 
-		if (scope_add_symbol(to, def))
+		if (scope_add_type(to, def))
 			return -1;
 	}
 
-	foreach(visible, symbol, &from->traits) {
-		struct ast *def = symbol->data;
+	foreach(visible, trait, &from->traits) {
+		struct ast *def = trait->data;
 		if (!reexport && def->scope != from)
 			continue;
 
 		if (!ast_flags(def, AST_FLAG_PUBLIC))
 			continue;
 
-		if (scope_add_symbol(to, def))
+		if (scope_add_trait(to, def))
+			return -1;
+	}
+
+	foreach(visible, template, &from->templates) {
+		struct ast *def = template->data;
+		if (!reexport && def->scope != from)
+			continue;
+
+		if (!ast_flags(def, AST_FLAG_PUBLIC))
+			continue;
+
+		if (scope_add_template(to, def))
 			return -1;
 	}
 
@@ -677,9 +1086,10 @@ static struct type *fwd_type_kind(fwd_type_t type)
 	switch (type) {
 	case FWD_VOID: return tgen_void(NULL_LOC());
 	case FWD_I64: return tgen_type(TYPE_I64, NULL, NULL, NULL_LOC());
+	case FWD_U64: return tgen_type(TYPE_U64, NULL, NULL, NULL_LOC());
 	case FWD_PTR: {
-		struct type *base = tgen_void(NULL_LOC());
-		return tgen_ptr(base, NULL_LOC());
+		/* hack? */
+		return tgen_nil(NULL_LOC());
 	}
 
 	default:
@@ -697,20 +1107,42 @@ int fwd_register(struct fwd_state *state, const char *name, fwd_extern_t func, f
 
 	va_list args;
 	va_start(args, rtype);
+
+	size_t idx = 0;
 	while (1) {
 		fwd_type_t type = va_arg(args, enum fwd_type);
 		if (type == FWD_END)
 			break;
 
-		struct ast *new = gen_var(strdup("arg"), fwd_type_kind(type), NULL_LOC());
+		/* eight bytes is likely more than enough, since first three are
+		 * var, then we have four bytes for indexes and one trailing
+		 * NULL */
+		char *name = calloc(8, sizeof(char));
+		assert(name);
+
+		sprintf(name, "%s%zu", "var", idx);
+		struct ast *new = gen_var(name, fwd_type_kind(type), NULL_LOC());
 
 		if (vars)
-			vars->n = new;
-		else
-			vars = new;
+			new->n = vars;
+
+		vars = new;
+		idx++;
 	}
 	va_end(args);
 
+	/* append 'return' as a continuation */
+	if (rtype != FWD_VOID) {
+		char *name = strdup("ret");
+		struct ast *new = gen_var(name,
+				tgen_closure(fwd_type_kind(rtype), NULL_LOC()),
+				NULL_LOC());
+		if (vars)
+			new->n = vars;
+
+		vars = new;
+	}
+
 	vars = reverse_ast_list(vars);
 
 	struct ast *def = gen_proc(strdup(name), vars,
@@ -737,8 +1169,7 @@ int analyze_root(struct scope *scope, struct ast *root)
 		      break;
 
 		case AST_STRUCT_CONT:
-		      if (scope_add_chain(scope, node))
-			      return -1;
+		      abort();
 		      break;
 
 		case AST_TRAIT_DEF:
@@ -756,6 +1187,19 @@ int analyze_root(struct scope *scope, struct ast *root)
 			return -1;
 		}
 
+		case AST_TEMPLATE:
+		      if (scope_add_template(scope, node))
+			      return -1;
+		      break;
+
+		case AST_SUPERTEMPLATE:
+		      if (scope_add_template(scope, node))
+			      return -1;
+		      break;
+
+		case AST_INSTANCE:
+		      break;
+
 		default:
 		      abort();
 		}