initial reference checking

1 files changed, 45 insertions, 32 deletions

diff --git a/src/analyze.c b/src/analyze.c
index ab08f01..dd85c08 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -36,8 +36,8 @@ static int analyze_proc(struct state *state, struct scope *scope,
 	if (analyze_list(&proc_state, proc_scope, proc_params(node)))
 		return -1;
 
-	struct type *callable = tgen_callable(NULL, node->loc);
-	if (!callable) {
+	struct type *proc_type = tgen_func_ptr(NULL, node->loc);
+	if (!proc_type) {
 		internal_error("failed allocating proc type");
 		return -1;
 	}
@@ -53,10 +53,10 @@ static int analyze_proc(struct state *state, struct scope *scope,
 		/* otherwise same or ending group, don't increment */
 
 		param->t->group = group;
-		type_append(&callable->t0, clone_type(param->t));
+		type_append(&proc_type->t0, clone_type(param->t));
 	}
 
-	node->t = callable;
+	node->t = proc_type;
 
 	return analyze(&proc_state, proc_scope, proc_body(node));
 }
@@ -179,7 +179,6 @@ static int analyze_let(struct state *state, struct scope *scope,
 		return -1;
 	}
 
-	/** @todo check move semantics, maybe in another pass? */
 	node->t = l;
 	return 0;
 }
@@ -249,7 +248,28 @@ static int analyze_call(struct state *state, struct scope *scope,
 		return -1;
 	}
 
-	/** @todo check move semantics? */
+	return 0;
+}
+
+static int analyze_ref(struct state *state, struct scope *scope,
+                       struct ast *node)
+{
+	struct ast *expr = ref_base(node);
+	if (analyze(state, scope, expr))
+		return -1;
+
+	if (!is_lvalue(expr)) {
+		semantic_error(node->scope, node, "trying to reference rvalue");
+		return -1;
+	}
+
+	struct type *ref = tgen_ref(expr->t, node->loc);
+	if (!ref) {
+		internal_error("failed allocating ref type");
+		return -1;
+	}
+
+	node->t = ref;
 	return 0;
 }
 
@@ -295,15 +315,17 @@ static int analyze_closure(struct state *state, struct scope *scope,
 	if (analyze(state, closure_scope, closure_body(node)))
 		return -1;
 
-	struct type *callable = tgen_callable(NULL, node->loc);
+	struct type *callable = NULL;
+	if (ast_flags(node, AST_FLAG_NOMOVES))
+		callable = tgen_pure_closure(NULL, node->loc);
+	else
+		callable = tgen_closure(NULL, node->loc);
+
 	if (!callable) {
 		internal_error("failed allocating closure type");
 		return -1;
 	}
 
-	/** @todo use analysis to figure out if this closure can be called
-	 * multiple times or just once */
-
 	foreach_node(binding, closure_bindings(node)) {
 		type_append(&callable->t0, clone_type(binding->t));
 	}
@@ -417,28 +439,19 @@ static int analyze(struct state *state, struct scope *scope, struct ast *node)
 	}
 
 	switch (node->k) {
-	case AST_PROC_DEF:      ret = analyze_proc      (state, scope, node);
-		break;
-	case AST_VAR_DEF:       ret = analyze_var       (state, scope, node);
-		break;
-	case AST_BLOCK:         ret = analyze_block     (state, scope, node);
-		break;
-	case AST_LET:           ret = analyze_let       (state, scope, node);
-		break;
-	case AST_INIT:          ret = analyze_init      (state, scope, node);
-		break;
-	case AST_CALL:          ret = analyze_call      (state, scope, node);
-		break;
-	case AST_ID:            ret = analyze_id        (state, scope, node);
-		break;
-	case AST_IF:            ret = analyze_if        (state, scope, node);
-		break;
-	case AST_CLOSURE:       ret = analyze_closure   (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_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;
+	case AST_BLOCK: ret = analyze_block(state, scope, node); break;
+	case AST_INIT: ret = analyze_init(state, scope, node); break;
+	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_ID: ret = analyze_id(state, scope, node); break;
+	case AST_IF: ret = analyze_if(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_EMPTY:
 		node->t = tgen_void(node->loc);