WIP: rewrite C++ backend to be CHEADmaster

+ C allows for a bit more control, and we can manually handle closure
  contexts. For example `examples/fib.fwd` now works for effectively any
  `n`, pretty cool.

+ Fairly slow Fibonacci, I must admit. Initial profiling indicates it's
  mainly due to branch mispredictions, but I'll have to look into this a
  bit deeper.

+ The code is a bit hacked together, for now I'm more interested in
  getting things working, I'll worry about making things pretty later.

+ For testing, there's also initial support for modules, just so I can
  print stuff to the terminal

+ This commit is way too big, lol

1 files changed, 4 insertions, 133 deletions

diff --git a/src/move.c b/src/move.c
index 602b620..9e8cfa0 100644
--- a/src/move.c
+++ b/src/move.c
@@ -45,38 +45,6 @@ static struct state create_state(struct state *parent)
 static void destroy_state(struct state *state)
 {
 	moved_destroy(&state->moved);
-	moved_destroy(&state->queued);
-	moved_destroy(&state->referenced);
-}
-
-struct rm_move {
-	struct ast_pair data;
-	struct state *owner;
-};
-
-static struct rm_move remove_move(struct state *state, struct ast *def)
-{
-	if (!state)
-		return (struct rm_move){.data = {}, .owner = NULL};
-
-	struct ast_pair search = {.def = def};
-	struct ast_pair *found = moved_find(&state->moved, search);
-	if (found) {
-		moved_remove_found(&state->moved, found);
-		struct rm_move r = {.data = *found, .owner = state};
-		moved_free_found(&state->moved, found);
-		return r;
-	}
-
-	return remove_move(state->parent, def);
-}
-
-static void reinsert_move(struct rm_move move)
-{
-	if (!move.owner)
-		return;
-
-	moved_insert(&move.owner->moved, move.data);
 }
 
 static struct ast_pair *find_move(struct state *state, struct ast *def)
@@ -164,33 +132,6 @@ static void push_up(struct state *state)
 	merge(parent, state);
 }
 
-static void mark_queued(struct state *state)
-{
-	if (moved_len(&state->moved) == 0)
-		return;
-
-	foreach(moved, m, &state->moved) {
-		moved_insert(&state->queued, *m);
-	}
-
-	/* empty out moves now that they're all queued */
-	moved_destroy(&state->moved);
-	state->moved = moved_create();
-}
-
-static void mark_unqueued(struct state *state)
-{
-	if (moved_len(&state->queued) == 0)
-		return;
-
-	foreach(moved, q, &state->queued) {
-		moved_insert(&state->moved, *q);
-	}
-
-	moved_destroy(&state->queued);
-	state->queued = moved_create();
-}
-
 static void forget_references(struct state *state)
 {
 	moved_destroy(&state->referenced);
@@ -295,10 +236,10 @@ static int total_check_single(struct state *state, struct scope *scope)
 static int total_check_proc(struct state *state, struct scope *scope)
 {
 	int ret = total_check_single(state, scope);
-	if (scope->flags & SCOPE_PROC)
+	if (!scope->parent)
 		return ret;
 
-	if (!scope->parent)
+	if (scope->flags & SCOPE_PROC)
 		return ret;
 
 	return ret | total_check_proc(state, scope->parent);
@@ -313,21 +254,10 @@ static int mvcheck_block(struct state *state, struct ast *node)
 		return ret;
 	}
 
-	if (block_error(node)) {
-		if (total_check_proc(&new_state, node->scope))
-			semantic_info(node->scope, node, "at end of block");
-
-		/* mark us queued so moves are not visible for the next scopes,
-		 * but appear to the caller function if we're in a closure */
-		mark_queued(&new_state);
-		push_up(&new_state);
-		destroy_state(&new_state);
-		return 0;
-	}
-
 	if (total_check_single(&new_state, node->scope))
 		semantic_info(node->scope, node, "at end of block");
 
+	/** @todo add exit analysis and run total_check_proc on those blocks */
 	push_up(&new_state);
 	destroy_state(&new_state);
 	return 0;
@@ -361,7 +291,6 @@ static int mvcheck_call(struct state *state, struct ast *node)
 
 		struct state arg_state = create_state(state);
 		ret = mvcheck(&arg_state, arg);
-		mark_unqueued(&arg_state);
 
 		merge(&group_state, &arg_state);
 		destroy_state(&arg_state);
@@ -382,41 +311,8 @@ static int mvcheck_call(struct state *state, struct ast *node)
 
 	destroy_state(&group_state);
 
-	/* the next section looks a bit weird, but it kind of makes sense. We
-	 * don't know when the error branch might get taken, so we first check
-	 * it 'before' the moves from any possible closures take place to see if
-	 * there's a possibility that some variable gets leaked. The second time
-	 * around we take the closure moves into account to see if the error
-	 * branch might accidentally move an already moved variable, i.e. the
-	 * user would need to add `own` blocks. */
-
-	/** @todo this is more or less what needs to happen for correctness, but
-	 * might mean that warnings from leaks in the first check get reprinted
-	 * in the second round, should probably add in some mechanism to check
-	 * against that */
-	if (call_err(node)) {
-		struct state err_state = create_state(state);
-		ret |= mvcheck(&err_state, call_err(node));
-		destroy_state(&err_state);
-	}
-	else if (total_check_proc(state, node->scope)) {
-		semantic_info(node->scope, node, "in implicit err branch");
-	}
-
 	push_up(&buffer_state);
 	destroy_state(&buffer_state);
-
-	if (call_err(node)) {
-		struct state err_state = create_state(state);
-		ret |= mvcheck(&err_state, call_err(node));
-
-		/* store results of this check */
-		push_up(&err_state);
-		destroy_state(&err_state);
-	}
-	/* no need to check implicit error branch since it by definition can't
-	 * move already moved variables */
-
 	return ret;
 }
 
@@ -584,30 +480,6 @@ static int mvcheck_statements(struct state *state, struct ast *nodes)
 	return 0;
 }
 
-static int mvcheck_err_branch(struct state *state, struct ast *node)
-{
-	return mvcheck(state, err_branch_body(node));
-}
-
-static int mvcheck_own(struct state *state, struct ast *node)
-{
-	struct ast *def = file_scope_find_symbol(node->scope, own_id(node));
-	assert(def);
-
-	if (is_callable(def->t)) {
-		semantic_error(node->scope, node,
-				"ownership of callable cannot be checked");
-		return -1;
-	}
-
-	struct rm_move prev = remove_move(state, def);
-	int ret = mvcheck(state, own_body(node));
-
-	/* insert back */
-	reinsert_move(prev);
-	return ret;
-}
-
 static int mvcheck(struct state *state, struct ast *node)
 {
 	if (is_unop(node))
@@ -624,8 +496,6 @@ static int mvcheck(struct state *state, struct ast *node)
 	case AST_BLOCK:         return mvcheck_block     (state, node);
 	case AST_CALL:          return mvcheck_call      (state, node);
 	case AST_CLOSURE:       return mvcheck_closure   (state, node);
-	case AST_ERR_BRANCH:	return mvcheck_err_branch(state, node);
-	case AST_OWN:		return mvcheck_own	 (state, node);
 	case AST_LET:           return mvcheck_let       (state, node);
 	case AST_ID:            return mvcheck_id        (state, node);
 	case AST_INIT:          return mvcheck_init      (state, node);
@@ -633,6 +503,7 @@ static int mvcheck(struct state *state, struct ast *node)
 	case AST_REF:           return mvcheck_ref       (state, node);
 	case AST_DEREF:         return mvcheck_deref     (state, node);
 	case AST_EMPTY:
+	case AST_IMPORT:
 	case AST_CONST_INT:
 	case AST_CONST_STR:
 	case AST_CONST_FLOAT: