add move queues

+ Returning blocks don't want to show moves for subsequent statements,
  but do want to show them for possible closure callers above.

5 files changed, 146 insertions, 34 deletions

diff --git a/examples/uniq.fwd b/examples/uniq.fwd
index c1edc1b..cc6e0af 100644
--- a/examples/uniq.fwd
+++ b/examples/uniq.fwd
@@ -10,11 +10,17 @@ fwd_some(optional![string] o,
 fwd_insert(unordered_set![string] set, string line,
 	(unordered_set![string]) next);
 
+fwd_destroy(auto a);
+
 /* at some point I'll probably add in a type system as well, but for now let's
  * pretend we're static-dynamic (or dynamic at compiletime? dunno) */
 readlines(unordered_set![string] set, (unordered_set![string]) next)
 {
 	fwd_getline() => optional![string] line;
+	!> e {
+		own set {fwd_destroy(set);}
+		error e
+	}
 
 	fwd_some(line) => string line {
 		/* we had something in our option */
diff --git a/lib/fwdlib.hpp b/lib/fwdlib.hpp
index 8e6be16..6af8441 100644
--- a/lib/fwdlib.hpp
+++ b/lib/fwdlib.hpp
@@ -71,4 +71,10 @@ static fwd_err_t fwd_intalloc(auto ok)
 	return ok(p);
 }
 
+static fwd_err_t fwd_destroy(auto /* a */)
+{
+	/* RAII destroys a */
+	return nullptr;
+}
+
 #endif /* FWDLIB_HPP */
diff --git a/src/analyze.c b/src/analyze.c
index 7eee49a..c33a901 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -10,6 +10,7 @@ struct state {
 };
 
 static int analyze(struct state *state, struct scope *scope, struct ast *node);
+static int analyze_known_block(struct state *state, struct scope *scope, struct ast *node);
 static int analyze_list(struct state *state, struct scope *scope,
                         struct ast *nodes);
 
@@ -58,8 +59,10 @@ static int analyze_proc(struct state *state, struct scope *scope,
 	}
 
 	node->t = proc_type;
+	if (!proc_body(node))
+		return 0;
 
-	return analyze(&proc_state, proc_scope, proc_body(node));
+	return analyze_known_block(&proc_state, proc_scope, proc_body(node));
 }
 
 static int analyze_unop(struct state *state, struct scope *scope,
@@ -132,29 +135,19 @@ static int analyze_comparison(struct state *state, struct scope *scope,
 	return 0;
 }
 
-static int analyze_block(struct state *state, struct scope *scope,
-                         struct ast *node)
+static int analyze_known_block(struct state *state, struct scope *scope, struct ast *node)
 {
-	struct scope *block_scope = create_scope();
-	if (!block_scope) {
-		internal_error("failed to allocate block scope");
-		return -1;
-	}
+	assert(node && node->k == AST_BLOCK);
 
-	scope_add_scope(scope, block_scope);
-	if (analyze_list(state, block_scope, block_body(node)))
+	node->scope = scope;
+	node->t = tgen_void(node->loc);
+	if (analyze_list(state, scope, block_body(node)))
 		return -1;
 
-	struct ast *last = ast_last(block_body(node));
-	if (last)
-		node->t = last->t;
-	else
-		node->t = tgen_void(node->loc);
-
-	if (!block_error(node))
+	struct ast *err = block_error(node);
+	if (!err)
 		return 0;
 
-	struct ast *err = block_error(node);
 	if (error_str(err))
 		return 0;
 
@@ -176,6 +169,19 @@ static int analyze_block(struct state *state, struct scope *scope,
 	return 0;
 }
 
+static int analyze_block(struct state *state, struct scope *scope,
+                         struct ast *node)
+{
+	struct scope *block_scope = create_scope();
+	if (!block_scope) {
+		internal_error("failed to allocate block scope");
+		return -1;
+	}
+
+	scope_add_scope(scope, block_scope);
+	return analyze_known_block(state, scope, node);
+}
+
 static int analyze_var(struct state *state, struct scope *scope,
                        struct ast *node)
 {
@@ -362,7 +368,7 @@ static int analyze_closure(struct state *state, struct scope *scope,
 	if (analyze_list(state, closure_scope, closure_bindings(node)))
 		return -1;
 
-	if (analyze(state, closure_scope, closure_body(node)))
+	if (analyze_known_block(state, closure_scope, closure_body(node)))
 		return -1;
 
 	struct type *callable = NULL;
@@ -387,6 +393,9 @@ static int analyze_closure(struct state *state, struct scope *scope,
 static int analyze_int(struct state *state, struct scope *scope,
                        struct ast *node)
 {
+	(void)state;
+	(void)scope;
+
 	/** @todo do this properly, very hacky, bad bad bad */
 	char *i = strdup("int");
 	if (!i) {
@@ -407,6 +416,9 @@ static int analyze_int(struct state *state, struct scope *scope,
 static int analyze_str(struct state *state, struct scope *scope,
                        struct ast *node)
 {
+	(void)state;
+	(void)scope;
+
 	/** @todo do this properly, very hacky, bad bad bad */
 	char *i = strdup("char");
 	if (!i) {
diff --git a/src/lower.c b/src/lower.c
index b683e0b..8d3e4ea 100644
--- a/src/lower.c
+++ b/src/lower.c
@@ -322,6 +322,9 @@ static int lower_mark_moved(struct state *state, struct ast *moves)
 	return 0;
 }
 
+/** @todo this is probably more complicated than it really needs to be, maybe
+ * refactor into lower_checked_call and lower_implicit_call or something for
+ * explicit and implicit error handling cases? */
 static int lower_call(struct state *state, struct ast *call, bool ret)
 {
 	struct ast *err = call_err(call);
@@ -351,12 +354,28 @@ static int lower_call(struct state *state, struct ast *call, bool ret)
 	}
 
 	printf("))");
-	if (err)
-		return lower_err_branch(state, err);
+	if (err) {
+		if (lower_err_branch(state, err))
+			return -1;
+
+		if (ret) {
+			printf("\n");
+			indent(state);
+			printf("return nullptr;\n");
+		}
+
+		return 0;
+	}
 
 	printf("\n");
 	indent(state);
 	printf(" return %s;\n", err_str);
+
+	if (ret) {
+		indent(state);
+		printf("return nullptr;\n");
+	}
+
 	return 0;
 }
 
diff --git a/src/move.c b/src/move.c
index 6ed687b..e11c2be 100644
--- a/src/move.c
+++ b/src/move.c
@@ -12,6 +12,7 @@ struct ast_pair {
 
 struct state {
 	struct moved moved;
+	struct moved queued;
 	struct moved referenced;
 	struct state *parent;
 
@@ -35,6 +36,7 @@ static struct state create_state(struct state *parent)
 	struct state state = {};
 	state.parent = parent;
 	state.pure = false;
+	state.queued = moved_create();
 	state.moved = moved_create();
 	state.referenced = moved_create();
 	return state;
@@ -43,6 +45,7 @@ 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);
 }
 
@@ -123,6 +126,16 @@ static void merge_moves(struct state *to, struct state *from)
 	}
 }
 
+static void merge_queued(struct state *to, struct state *from)
+{
+	if (moved_len(&from->queued) == 0)
+		return;
+
+	foreach(moved, n, &from->queued) {
+		moved_insert(&to->queued, *n);
+	}
+}
+
 static void merge_references(struct state *to, struct state *from)
 {
 	if (moved_len(&from->referenced) == 0)
@@ -136,6 +149,7 @@ static void merge_references(struct state *to, struct state *from)
 static void merge(struct state *to, struct state *from)
 {
 	merge_moves(to, from);
+	merge_queued(to, from);
 	merge_references(to, from);
 }
 
@@ -148,9 +162,37 @@ 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);
+	state->referenced = moved_create();
 }
 
 static int mvcheck(struct state *state, struct ast *node);
@@ -270,12 +312,13 @@ static int mvcheck_block(struct state *state, struct ast *node)
 	}
 
 	if (block_error(node)) {
-		/* don't push state up since there's no way to continue
-		 * execution after an error, so whatever code follows this
-		 * didn't see any moves take place */
 		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;
 	}
@@ -306,20 +349,17 @@ static int mvcheck_call(struct state *state, struct ast *node)
 			return -1;
 	}
 
-	/* check if there are any arguments that might not be moved if function
-	 * returns immediately */
-	if (!call_err(node) && total_check_proc(state, node->scope))
-		semantic_info(node->scope, node, "in implicit error branch");
-
 	/* check into closures */
 	int ret = 0;
-	struct state group_state = create_state(state);
+	struct state buffer_state = create_state(state);
+	struct state group_state = create_state(&buffer_state);
 	foreach_node(arg, call_args(node)) {
 		if (arg->k != AST_CLOSURE)
 			continue;
 
 		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);
@@ -329,7 +369,7 @@ static int mvcheck_call(struct state *state, struct ast *node)
 			/* this group ended, push state immediately */
 			push_up(&group_state);
 
-			/* something like reset_state would maybe me more clear? */
+			/* something like reset_state would maybe be more clear? */
 			destroy_state(&group_state);
 			group_state = create_state(state);
 		}
@@ -338,14 +378,43 @@ static int mvcheck_call(struct state *state, struct ast *node)
 			break;
 	}
 
-	if (!ret && call_err(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));
+		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 */
 
-	destroy_state(&group_state);
 	return ret;
 }