detect leaks

12 files changed, 444 insertions, 54 deletions

diff --git a/examples/err.fwd b/examples/err.fwd
new file mode 100644
index 0000000..f2833e2
--- /dev/null
+++ b/examples/err.fwd
@@ -0,0 +1,17 @@
+do_something((auto, auto) ok);
+
+/* consume can fail */
+consume(auto a);
+
+main()
+{
+	do_something() => auto a, auto b;
+	consume(a);
+	/* try commenting out error handler or consume(b); */
+	!> e {
+		consume(b);
+		error "a failed"
+	}
+
+	consume(b);
+}
diff --git a/examples/own.fwd b/examples/own.fwd
new file mode 100644
index 0000000..6634886
--- /dev/null
+++ b/examples/own.fwd
@@ -0,0 +1,33 @@
+do_something((auto) a);
+consume(auto a);
+
+main()
+{
+	do_something() => auto a;
+	do_something() => auto b;
+	!> e {
+		/* if do_something() fails, a is still alive, so we must kill
+		 * it. However, we might enter this error block after the
+		 * callback to do_something() was run, and a might've already
+		 * been moved. own just checks if we still own the resource and
+		 * executes the block.
+		 *
+		 * admittedly, purely syntactically it would look like b is
+		 * already alive at this point, but since it's actually within
+		 * the implicit closure, it is not. Might play around with ordering
+		 * the error block to come before implicit closures...
+		 */
+		own a {consume(a);}
+		error e
+	}
+
+	consume(a);
+	!> e {
+		/* if consume fails, b is still alive, but either this error
+		 * block runs (and throws an error) or the next consume is run,
+		 * so own is not necessary here */
+		consume(b);
+		error e
+	}
+	consume(b);
+}
diff --git a/include/fwd/ast.h b/include/fwd/ast.h
index 726b5e3..5f2b7cb 100644
--- a/include/fwd/ast.h
+++ b/include/fwd/ast.h
@@ -32,7 +32,7 @@ struct ast;
 
 enum type_kind {
 	TYPE_ID = 1, TYPE_CONSTRUCT, TYPE_REF, TYPE_PTR, TYPE_CLOSURE,
-	TYPE_PURE_CLOSURE, TYPE_FUNC_PTR, TYPE_VOID
+	TYPE_PURE_CLOSURE, TYPE_FUNC_PTR, TYPE_VOID, TYPE_ERR
 };
 
 struct type {
@@ -59,6 +59,14 @@ enum ast_kind {
 	AST_LET = 1,
 	/** If statement */
 	AST_IF,
+	/** Nil check */
+	AST_NIL,
+	/* Owning check */
+	AST_OWN,
+	/** Err branch */
+	AST_ERR_BRANCH,
+	/** Error throwing */
+	AST_ERROR,
 	/** Call procedure. */
 	AST_CALL,
 	/** Procedure definition. */
@@ -266,6 +274,7 @@ static inline bool is_trivially_copyable(struct type *type)
 	switch (type->k) {
 	case TYPE_REF:
 	case TYPE_PTR:
+	case TYPE_ERR:
 	case TYPE_FUNC_PTR:
 	case TYPE_PURE_CLOSURE:
 		/** @todo primitive types */
@@ -309,6 +318,9 @@ static inline bool is_trivially_copyable(struct type *type)
 #define tgen_void(loc) \
 	tgen_type(TYPE_VOID, NULL, NULL, loc)
 
+#define tgen_err(loc) \
+	tgen_type(TYPE_ERR, NULL, NULL, loc)
+
 #define tid_str(x) return_id(x, TYPE_ID)
 #define tgen_id(id, loc) \
 	tgen_type(TYPE_ID, NULL, id, loc)
@@ -359,8 +371,9 @@ static inline bool is_trivially_copyable(struct type *type)
 
 #define call_expr(x) return_a0(x, AST_CALL)
 #define call_args(x) return_a1(x, AST_CALL)
-#define gen_call(expr, args, loc) \
-	gen2(AST_CALL, expr, args, loc)
+#define call_err(x) return_a2(x, AST_CALL)
+#define gen_call(expr, args, err, loc) \
+	gen3(AST_CALL, expr, args, err, loc)
 
 #define proc_id(x) return_s(x, AST_PROC_DEF)
 #define proc_params(x) return_a0(x, AST_PROC_DEF)
@@ -379,9 +392,20 @@ static inline bool is_trivially_copyable(struct type *type)
 #define gen_var(id, type, loc) \
 	gen_ast(AST_VAR_DEF, NULL, NULL, NULL, NULL, type, id, 0, 0., loc)
 
+#define err_branch_id(x) return_s(x, AST_ERR_BRANCH)
+#define err_branch_body(x) return_a0(x, AST_ERR_BRANCH)
+#define gen_err_branch(id, body, loc) \
+	gen_ast(AST_ERR_BRANCH, body, NULL, NULL, NULL, NULL, id, 0, 0., loc)
+
+#define error_str(x) return_s(x, AST_ERROR)
+#define error_id(x) return_a0(x, AST_ERROR)
+#define gen_error(str, id, loc) \
+	gen_ast(AST_ERROR, id, NULL, NULL, NULL, NULL, str, 0, 0., loc)
+
 #define block_body(x) return_a0(x, AST_BLOCK)
-#define gen_block(body, loc) \
-	gen1(AST_BLOCK, body, loc)
+#define block_error(x) return_a1(x, AST_BLOCK)
+#define gen_block(body, err, loc) \
+	gen2(AST_BLOCK, body, err, loc)
 
 #define str_val(x) return_s(x, AST_CONST_STR)
 #define gen_const_str(s, loc) \
@@ -420,6 +444,17 @@ static inline bool is_trivially_copyable(struct type *type)
 #define gen_if(cond, body, els, loc) \
 	gen3(AST_IF, cond, body, els, loc)
 
+#define nil_var(x) return_s(x, AST_NIL)
+#define nil_body(x) return_a1(x, AST_NIL)
+#define nil_ref(x) return_a2(x, AST_NIL)
+#define gen_nil(var, body, ref, loc) \
+	gen_ast(AST_NIL, NULL, body, ref, NULL, NULL, var, 0, 0., loc)
+
+#define own_id(x) return_s(x, AST_OWN)
+#define own_body(x) return_a1(x, AST_OWN)
+#define gen_own(var, body, loc) \
+	gen_ast(AST_OWN, NULL, body, NULL, NULL, NULL, var, 0, 0., loc)
+
 #define id_str(x) return_s(x, AST_ID)
 #define gen_id(id, loc) \
 	gen_str(AST_ID, id, loc)
diff --git a/include/fwd/scope.h b/include/fwd/scope.h
index 6a78793..2e71cdb 100644
--- a/include/fwd/scope.h
+++ b/include/fwd/scope.h
@@ -32,6 +32,10 @@ struct visible {
 	struct visible *next;
 };
 
+enum scope_flags {
+	SCOPE_PROC = (1 << 0),
+};
+
 /**
  * Scope.
  * Responsible for keeping track of visibilities and
@@ -60,6 +64,8 @@ struct scope {
 	struct scope *children;
 
 	struct visible *symbols;
+
+	enum scope_flags flags;
 };
 
 /**
diff --git a/lib/fwdlib.hpp b/lib/fwdlib.hpp
index 623dc13..51450c1 100644
--- a/lib/fwdlib.hpp
+++ b/lib/fwdlib.hpp
@@ -10,7 +10,9 @@
 
 using namespace std;
 
-static void fwd_getline(auto next)
+typedef const char *fwd_err_t;
+
+static fwd_err_t fwd_getline(auto next)
 {
 	if (cin.eof())
 		return next(optional<string>{});
@@ -21,13 +23,13 @@ static void fwd_getline(auto next)
 		return next(optional<string>{});
 }
 
-static void fwd_foreach(auto container, auto next)
+static fwd_err_t fwd_foreach(auto container, auto next)
 {
 	for (auto &n : container)
 		next(n);
 }
 
-static void fwd_some(auto option, auto ok, auto fail)
+static fwd_err_t fwd_some(auto option, auto ok, auto fail)
 {
 	if (option)
 		return ok(std::move(option.value()));
@@ -35,12 +37,12 @@ static void fwd_some(auto option, auto ok, auto fail)
 		return fail();
 }
 
-static void fwd_copy(auto n, auto next)
+static fwd_err_t fwd_copy(auto n, auto next)
 {
 	return next(n, n);
 }
 
-static void fwd_null(auto *x, auto fail, auto ok)
+static fwd_err_t fwd_null(auto *x, auto fail, auto ok)
 {
 	if (x)
 		return ok(*x);
@@ -48,18 +50,19 @@ static void fwd_null(auto *x, auto fail, auto ok)
 		return fail();
 }
 
-static void fwd_insert(auto container, auto elem, auto next)
+static fwd_err_t fwd_insert(auto container, auto elem, auto next)
 {
 	container.insert(std::move(elem));
 	return next(std::move(container));
 }
 
-static void fwd_println(auto elem)
+static fwd_err_t fwd_println(auto elem)
 {
 	cout << elem << endl;
+	return nullptr;
 }
 
-static void fwd_intalloc(auto ok)
+static fwd_err_t fwd_intalloc(auto ok)
 {
 	int *p = new int{20};
 	ok(p);
diff --git a/src/analyze.c b/src/analyze.c
index 8e76892..7eee49a 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -30,6 +30,7 @@ static int analyze_proc(struct state *state, struct scope *scope,
 		return -1;
 	}
 
+	proc_scope->flags |= SCOPE_PROC;
 	scope_add_scope(scope, proc_scope);
 
 	struct state proc_state = {};
@@ -150,6 +151,28 @@ static int analyze_block(struct state *state, struct scope *scope,
 	else
 		node->t = tgen_void(node->loc);
 
+	if (!block_error(node))
+		return 0;
+
+	struct ast *err = block_error(node);
+	if (error_str(err))
+		return 0;
+
+	struct ast *id = error_id(err);
+	assert(id);
+
+	struct ast *def = file_scope_find_symbol(scope, id_str(id));
+	if (!def) {
+		semantic_error(scope, id, "no such symbol");
+		return -1;
+	}
+
+	struct type *t = def->t;
+	if (t->k != TYPE_ERR) {
+		semantic_error(scope, id, "invalid error variable type");
+		return -1;
+	}
+
 	return 0;
 }
 
@@ -248,7 +271,7 @@ static int analyze_call(struct state *state, struct scope *scope,
 		return -1;
 	}
 
-	return 0;
+	return analyze(state, scope, call_err(node));
 }
 
 static int analyze_ref(struct state *state, struct scope *scope,
@@ -332,6 +355,8 @@ static int analyze_closure(struct state *state, struct scope *scope,
 		return -1;
 	}
 
+	node->scope = closure_scope;
+	closure_scope->flags |= SCOPE_PROC;
 	scope_add_scope(scope, closure_scope);
 
 	if (analyze_list(state, closure_scope, closure_bindings(node)))
@@ -427,6 +452,40 @@ static int analyze_if(struct state *state, struct scope *scope,
 	return 0;
 }
 
+static int analyze_err_branch(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct scope *branch_scope = create_scope();
+	if (!branch_scope) {
+		internal_error("failed allocating err branch scope");
+		return -1;
+	}
+
+	node->t = tgen_void(node->loc);
+
+	scope_add_scope(scope, branch_scope);
+	struct ast *var = gen_var(strdup(err_branch_id(node)), NULL, node->loc);
+	struct type *err_type = tgen_err(node->loc);
+	var->t = err_type;
+	scope_add_var(branch_scope, var);
+	return analyze(state, branch_scope, err_branch_body(node));
+}
+
+static int analyze_own(struct state *state, struct scope *scope, struct ast *node)
+{
+	struct ast *found = file_scope_find_symbol(scope, own_id(node));
+	if (!found) {
+		semantic_error(scope, node, "no symbol named \"%s\"",
+				own_id(node));
+		return -1;
+	}
+
+	if (is_trivially_copyable(found->t))
+		semantic_warn(scope, node, "trivially copyable type is never owned");
+
+	node->t = tgen_void(node->loc);
+	return analyze(state, scope, own_body(node));
+}
+
 static int analyze(struct state *state, struct scope *scope, struct ast *node)
 {
 	if (!node)
@@ -464,6 +523,7 @@ static int analyze(struct state *state, struct scope *scope, struct ast *node)
 	}
 
 	switch (node->k) {
+	case AST_ERR_BRANCH: ret = analyze_err_branch(state, scope, node); break;
 	case AST_CLOSURE: ret = analyze_closure(state, scope, node); break;
 	case AST_PROC_DEF: ret = analyze_proc(state, scope, node); break;
 	case AST_VAR_DEF: ret = analyze_var(state, scope, node); break;
@@ -473,6 +533,7 @@ static int analyze(struct state *state, struct scope *scope, struct ast *node)
 	case AST_CALL: ret = analyze_call(state, scope, node); break;
 	case AST_REF: ret = analyze_ref(state, scope, node); break;
 	case AST_LET: ret = analyze_let(state, scope, node); break;
+	case AST_OWN: ret = analyze_own(state, scope, node); break;
 	case AST_ID: ret = analyze_id(state, scope, node); break;
 	case AST_IF: ret = analyze_if(state, scope, node); break;
 
diff --git a/src/ast.c b/src/ast.c
index 08178f7..f491b55 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -201,6 +201,10 @@ void ast_dump(int depth, struct ast *n)
 	switch (n->k) {
 	DUMP(AST_CLOSURE);
 	DUMP(AST_IF);
+	DUMP(AST_NIL);
+	DUMP(AST_OWN);
+	DUMP(AST_ERR_BRANCH);
+	DUMP(AST_ERROR);
 	DUMP(AST_LET);
 	DUMP(AST_INIT);
 	DUMP(AST_CALL);
@@ -558,7 +562,7 @@ void fix_closures(struct ast *root)
 
 		assert(next);
 
-		struct ast *block = gen_block(next, root->loc);
+		struct ast *block = gen_block(next, NULL, root->loc);
 		closure_body(arg) = block;
 		root->n = NULL;
 		root = next;
@@ -627,6 +631,10 @@ const char *ast_str(enum ast_kind k)
 	switch (k) {
 	CASE(AST_CLOSURE);
 	CASE(AST_IF);
+	CASE(AST_NIL);
+	CASE(AST_OWN);
+	CASE(AST_ERR_BRANCH);
+	CASE(AST_ERROR);
 	CASE(AST_LET);
 	CASE(AST_INIT);
 	CASE(AST_CALL);
diff --git a/src/debug.c b/src/debug.c
index 1f4d3a8..b13a459 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -177,6 +177,10 @@ static void _type_str(FILE *f, struct type *type)
 		return;
 
 	switch (type->k) {
+	case TYPE_ERR:
+		fprintf(f, "err");
+		break;
+
 	case TYPE_VOID:
 		fprintf(f, "void");
 		break;
diff --git a/src/lexer.l b/src/lexer.l
index ccae93e..e11b51e 100644
--- a/src/lexer.l
+++ b/src/lexer.l
@@ -122,12 +122,17 @@ STRING		\"(\\.|[^"\\])*\"
 "=="		{return EQ;}
 
 "=>"		{return FATARROW;}
+"!>"		{return ERRARROW;}
 
 "<<"		{return LSHIFT;}
 ">>"		{return RSHIFT;}
 
 "if"		{return IF;}
 "else"		{return ELSE;}
+"nil"		{return NIL;}
+"own"		{return OWN;}
+
+"error"		{return ERROR;}
 
 "mut"		{return MUT;}
 
diff --git a/src/lower.c b/src/lower.c
index df095e4..141453c 100644
--- a/src/lower.c
+++ b/src/lower.c
@@ -34,7 +34,7 @@ static void indent(struct state *state)
 static int lower_var(struct ast *expr);
 
 static int lower_expr(struct state *state, struct ast *expr);
-static int lower_block(struct state *state, struct ast *block);
+static int lower_block(struct state *state, struct ast *block, bool ret);
 static int lower_closure(struct state *state, struct ast *closure);
 static int lower_statement(struct state *state, struct ast *stmt);
 
@@ -287,8 +287,18 @@ static int lower_moves(struct state *state, struct ast *moves)
 	return 0;
 }
 
+static int lower_err_branch(struct state *state, struct ast *err)
+{
+	return lower_block(state, err_branch_body(err), false);
+}
+
 static int lower_call(struct state *state, struct ast *call)
 {
+	struct ast *err = call_err(call);
+	/** @todo better default error name? */
+	const char *err_str = err ? err_branch_id(err) : "_fwd_err";
+
+	printf("if (auto %s = ", err_str);
 	if (lower_expr(state, call_expr(call)))
 		return -1;
 
@@ -297,7 +307,19 @@ static int lower_call(struct state *state, struct ast *call)
 	if (lower_moves(state, call_args(call)))
 		return -1;
 
-	printf(");\n");
+	printf("))");
+
+	if (!err) {
+		printf("\n");
+		indent(state);
+		printf(" return %s;\n", err_str);
+		return 0;
+	}
+
+	if (lower_err_branch(state, call_err(call)))
+		return -1;
+
+	printf("\n");
 	return 0;
 }
 
@@ -323,7 +345,7 @@ static int lower_if(struct state *state, struct ast *stmt)
 
 	printf(") ");
 
-	if (lower_block(state, if_body(stmt)))
+	if (lower_block(state, if_body(stmt), false))
 		return -1;
 
 	if (!if_else(stmt)) {
@@ -332,16 +354,36 @@ static int lower_if(struct state *state, struct ast *stmt)
 	}
 
 	printf(" else ");
-	if (lower_block(state, if_else(stmt)))
+	if (lower_block(state, if_else(stmt), false))
 		return -1;
 
 	printf("\n");
 	return 0;
 }
 
+static int lower_error(struct ast *err)
+{
+	assert(error_str(err) || error_id(err));
+	if (error_str(err)) {
+		printf("return %s;\n", error_str(err));
+		return 0;
+	}
+
+	struct ast *id = error_id(err);
+	printf("return %s;\n", id_str(id));
+	return 0;
+}
+
+static int lower_own(struct state *state, struct ast *stmt)
+{
+	printf("/* TODO own */\n");
+	return 0;
+}
+
 static int lower_statement(struct state *state, struct ast *stmt)
 {
 	switch (stmt->k) {
+	case AST_OWN:   return lower_own(state, stmt);
 	case AST_LET:   return lower_let(state, stmt);
 	case AST_CALL:  return lower_call(state, stmt);
 	case AST_IF:    return lower_if(state, stmt);
@@ -354,7 +396,7 @@ static int lower_statement(struct state *state, struct ast *stmt)
 	return 0;
 }
 
-static int lower_block(struct state *state, struct ast *block)
+static int lower_block(struct state *state, struct ast *block, bool ret)
 {
 	printf("{\n");
 	increase_indent(state);
@@ -366,8 +408,18 @@ static int lower_block(struct state *state, struct ast *block)
 			return -1;
 	}
 
-	decrease_indent(state);
+	if (block_error(block)) {
+		indent(state);
+		if (lower_error(block_error(block)))
+			return -1;
+	}
+
+	if (ret) {
+		indent(state);
+		printf("return nullptr;\n");
+	}
 
+	decrease_indent(state);
 	indent(state);
 	printf("}");
 	return 0;
@@ -407,7 +459,7 @@ static int lower_closure(struct state *state, struct ast *closure)
 
 	printf(")");
 
-	if (lower_block(state, closure_body(closure)))
+	if (lower_block(state, closure_body(closure), true))
 		return -1;
 
 	return 0;
@@ -420,12 +472,12 @@ static int lower_proto(struct ast *proc)
 	if (!proc_body(proc))
 		return 0;
 
+	printf("fwd_err_t ");
 	if (strcmp("main", proc_id(proc)) == 0)
-		printf("int ");
+		printf("fwd_main(");
 	else
-		printf("void ");
+		printf("%s(", proc_id(proc));
 
-	printf("%s(", proc_id(proc));
 
 	if (lower_vars(proc_params(proc)))
 		return -1;
@@ -439,12 +491,11 @@ static int lower_proc(struct ast *proc)
 	if (!proc_body(proc))
 		return 0;
 
+	printf("fwd_err_t ");
 	if (strcmp("main", proc_id(proc)) == 0)
-		printf("int ");
+		printf("fwd_main(");
 	else
-		printf("void ");
-
-	printf("%s(", proc_id(proc));
+		printf("%s(", proc_id(proc));
 
 	if (lower_vars(proc_params(proc)))
 		return -1;
@@ -452,7 +503,7 @@ static int lower_proc(struct ast *proc)
 	printf(")\n");
 
 	struct state state = {0};
-	if (lower_block(&state, proc_body(proc)))
+	if (lower_block(&state, proc_body(proc), true))
 		return -1;
 
 	printf("\n\n");
@@ -476,5 +527,15 @@ int lower(struct scope *root)
 			return -1;
 	}
 
+
+	puts("int main()");
+	puts("{");
+	puts("	fwd_err_t err = fwd_main();");
+	puts("	if (err) {");
+	puts("		fprintf(stderr, \"%s\", err);");
+	puts("		return -1;");
+	puts("	}");
+	puts("}");
+
 	return 0;
 }
diff --git a/src/move.c b/src/move.c
index 7f54427..a87d6dd 100644
--- a/src/move.c
+++ b/src/move.c
@@ -46,6 +46,34 @@ static void destroy_state(struct state *state)
 	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);
+		return (struct rm_move){.data = *found, .owner = state};
+	}
+
+	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)
 {
 	if (!state)
@@ -195,9 +223,66 @@ static int mvcheck_proc(struct state *state, struct ast *node)
 	return ret;
 }
 
+static int total_check_single(struct state *state, struct scope *scope)
+{
+	int ret = 0;
+	foreach_visible(n, scope->symbols) {
+		struct ast *def = n->node;
+		if (def->k != AST_VAR_DEF)
+			continue;
+
+		if (is_trivially_copyable(def->t))
+			continue;
+
+		struct ast_pair *prev = find_move(state, def);
+		if (prev)
+			continue;
+
+		semantic_warn(scope, def, "%s not moved, might leak", var_id(def));
+		ret |= 1;
+	}
+
+	return ret;
+}
+
+static int total_check_proc(struct state *state, struct scope *scope)
+{
+	int ret = total_check_single(state, scope);
+	if (scope->flags & SCOPE_PROC)
+		return ret;
+
+	if (!scope->parent)
+		return ret;
+
+	return ret | total_check_proc(state, scope->parent);
+}
+
 static int mvcheck_block(struct state *state, struct ast *node)
 {
-	return mvcheck_statements(state, block_body(node));
+	struct state new_state = create_state(state);
+	int ret = mvcheck_statements(&new_state, block_body(node));
+	if (ret) {
+		destroy_state(&new_state);
+		return ret;
+	}
+
+	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");
+
+		destroy_state(&new_state);
+		return 0;
+	}
+
+	if (total_check_single(&new_state, node->scope))
+		semantic_info(node->scope, node, "at end of block");
+
+	push_up(&new_state);
+	destroy_state(&new_state);
+	return 0;
 }
 
 static int mvcheck_call(struct state *state, struct ast *node)
@@ -233,6 +318,17 @@ static int mvcheck_call(struct state *state, struct ast *node)
 			break;
 	}
 
+	if (!ret && call_err(node)) {
+		struct state err_state = create_state(state);
+		ret = mvcheck(&err_state, call_err(node));
+		push_up(&err_state);
+		destroy_state(&err_state);
+	}
+	else if (!ret) {
+		if (total_check_proc(state, node->scope))
+			semantic_info(node->scope, node, "in implicit error branch");
+	}
+
 	destroy_state(&group_state);
 	return ret;
 }
@@ -244,8 +340,11 @@ static int mvcheck_closure(struct state *state, struct ast *node)
 
 	int ret = mvcheck(&new_state, closure_body(node));
 	push_up(&new_state);
-
 	destroy_state(&new_state);
+
+	if (total_check_single(state, node->scope))
+		semantic_info(node->scope, node, "in closure");
+
 	return ret;
 }
 
@@ -398,6 +497,24 @@ 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);
+
+	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))
@@ -410,16 +527,18 @@ static int mvcheck(struct state *state, struct ast *node)
 		return mvcheck_comparison(state, node);
 
 	switch (node->k) {
-	case AST_PROC_DEF:      return mvcheck_proc     (state, 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_LET:           return mvcheck_let      (state, node);
-	case AST_ID:            return mvcheck_id       (state, node);
-	case AST_INIT:          return mvcheck_init     (state, node);
-	case AST_IF:            return mvcheck_if       (state, node);
-	case AST_REF:           return mvcheck_ref      (state, node);
-	case AST_DEREF:         return mvcheck_deref    (state, node);
+	case AST_PROC_DEF:      return mvcheck_proc      (state, 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);
+	case AST_IF:            return mvcheck_if        (state, node);
+	case AST_REF:           return mvcheck_ref       (state, node);
+	case AST_DEREF:         return mvcheck_deref     (state, node);
 	case AST_EMPTY:
 	case AST_CONST_INT:
 	case AST_CONST_STR:
diff --git a/src/parser.y b/src/parser.y
index 751aaa1..68725a8 100644
--- a/src/parser.y
+++ b/src/parser.y
@@ -72,10 +72,14 @@
 %token RBRACKET "]"
 %token IF "if"
 %token ELSE "else"
+%token NIL "nil"
+%token OWN "own"
 %token MUT "mut"
+%token ERROR "error"
 %token DOT "."
 %token SCOPE "::"
 %token FATARROW "=>"
+%token ERRARROW "!>"
 
 %right "[" "]"
 /* precedence */
@@ -94,10 +98,10 @@
 %left "::"
 
 %nterm <node> top unit proc call closure var expr statement body
-%nterm <node> vars exprs statements closures trailing_closure
-%nterm <node> opt_vars opt_exprs opt_statements opt_trailing_closure
+%nterm <node> vars exprs statements closures err trailing_closure
+%nterm <node> opt_vars opt_exprs opt_statements opt_trailing_closure opt_err opt_error
 %nterm <node> rev_vars rev_exprs rev_closures rev_statements
-%nterm <node> let if unop binop construct
+%nterm <node> let if nil own unop binop construct
 
 %nterm <type> type rev_types types opt_types
 
@@ -299,7 +303,9 @@ opt_exprs
 	| { $$ = NULL; }
 
 closure
-	: "=>" opt_vars body { $$ = gen_closure($[opt_vars], $[body], src_loc(@$)); }
+	: "=>" opt_vars body {
+		$$ = gen_closure($[opt_vars], $[body], src_loc(@$));
+	}
 	| "&" "=>" opt_vars body {
 		$$ = gen_closure($[opt_vars], $[body], src_loc(@$));
 		ast_set_flags($$, AST_FLAG_NOMOVES);
@@ -330,20 +336,29 @@ closures
 		}
 	}
 
+err
+	: "!>" ID body {
+		$$ = gen_err_branch($2, $3, src_loc(@$));
+	}
+
+opt_err
+	: err
+	| { $$ = NULL; }
+
 call
-	: expr "(" opt_exprs ")" ";" {
-		$$ = gen_call($1, $[opt_exprs], src_loc(@$));
+	: expr "(" opt_exprs ")" ";" opt_err {
+		$$ = gen_call($1, $[opt_exprs], $[opt_err], src_loc(@$));
 	}
-	| expr "(" opt_exprs ")" "=>" opt_vars ";" {
+	| expr "(" opt_exprs ")" "=>" opt_vars ";" opt_err {
 		/* the rest of the function body is our closure, gets fixed up
 		 * later */
 		struct ast *closure = gen_closure($[opt_vars], NULL, src_loc(@$));
 		ast_append(&$[opt_exprs], closure);
-		$$ = gen_call($[expr], $[opt_exprs], src_loc(@$));
+		$$ = gen_call($[expr], $[opt_exprs], $[opt_err], src_loc(@$));
 	}
-	| expr "(" opt_exprs ")" closures {
+	| expr "(" opt_exprs ")" closures opt_err {
 		ast_append(&$[opt_exprs], $[closures]);
-		$$ = gen_call($[expr], $[opt_exprs], src_loc(@$));
+		$$ = gen_call($[expr], $[opt_exprs], $[opt_err], src_loc(@$));
 	}
 
 let
@@ -354,11 +369,32 @@ if
 	| "if" expr body "else" body { $$ = gen_if($2, $3, $5, src_loc(@$)); }
 	| "if" expr body "else" if { $$ = gen_if($2, $3, $5, src_loc(@$)); }
 
+nil
+	: "nil" ID body "=>" var {
+		$$ = gen_nil($2, $3, $5, src_loc(@$));
+	}
+
+own
+	: "own" ID body {
+		$$ = gen_own($2, $3, src_loc(@$));
+	}
+
+opt_error
+	: "error" STRING {
+		$$ = gen_error($2, NULL, src_loc(@$));
+	}
+	| "error" ID {
+		$$ = gen_error(NULL, gen_id($2, src_loc(@$)), src_loc(@$));
+	}
+	| { $$ = NULL; }
+
 statement
 	: call
+	| body
 	| let
+	| nil
+	| own
 	| if
-	| body
 	| ";" { $$ = gen_empty(src_loc(@$)); }
 
 rev_statements
@@ -373,7 +409,9 @@ opt_statements
 	| { $$ = NULL; }
 
 body
-	: "{" opt_statements "}" { $$ = gen_block($2, src_loc(@$)); }
+	: "{" opt_statements opt_error "}" {
+		$$ = gen_block($2, $3, src_loc(@$));
+	}
 
 top
 	: proc