Numpty forgot to add .c files

2026-07-31 03:40:08 +00:00 · 2016-11-23 14:41:20 +00:00
parent 4110324588
commit 7792f009b8
22 changed files with 23799 additions and 0 deletions
@@ -0,0 +1,545 @@
+bool check_is_terminating(AstNode *node);
+void check_stmt         (Checker *c, AstNode *node, u32 flags);
+void check_stmt_list    (Checker *c, AstNodeArray stmts, u32 flags);
+void check_type_decl    (Checker *c, Entity *e, AstNode *type_expr, Type *def, CycleChecker *cycle_checker);
+void check_const_decl   (Checker *c, Entity *e, AstNode *type_expr, AstNode *init_expr);
+void check_proc_decl    (Checker *c, Entity *e, DeclInfo *d);
+void check_var_decl     (Checker *c, Entity *e, Entity **entities, isize entity_count, AstNode *type_expr, AstNode *init_expr);
+
+// NOTE(bill): `content_name` is for debugging and error messages
+Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String context_name) {
+	if (operand->mode == Addressing_Invalid ||
+	    operand->type == t_invalid ||
+	    e->type == t_invalid) {
+
+		if (operand->mode == Addressing_Builtin) {
+			gbString expr_str = expr_to_string(operand->expr);
+
+			// TODO(bill): is this a good enough error message?
+			error(ast_node_token(operand->expr),
+			      "Cannot assign builtin procedure `%s` in %.*s",
+			      expr_str,
+			      LIT(context_name));
+
+			operand->mode = Addressing_Invalid;
+
+			gb_string_free(expr_str);
+		}
+
+
+		if (e->type == NULL) {
+			e->type = t_invalid;
+		}
+		return NULL;
+	}
+
+	if (e->type == NULL) {
+		// NOTE(bill): Use the type of the operand
+		Type *t = operand->type;
+		if (is_type_untyped(t)) {
+			if (t == t_invalid || is_type_untyped_nil(t)) {
+				error(e->token, "Use of untyped nil in %.*s", LIT(context_name));
+				e->type = t_invalid;
+				return NULL;
+			}
+			t = default_type(t);
+		}
+		e->type = t;
+	}
+
+	check_assignment(c, operand, e->type, context_name);
+	if (operand->mode == Addressing_Invalid) {
+		return NULL;
+	}
+
+	return e->type;
+}
+
+void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, AstNodeArray inits, String context_name) {
+	if ((lhs == NULL || lhs_count == 0) && inits.count == 0) {
+		return;
+	}
+
+	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena);
+
+	// NOTE(bill): If there is a bad syntax error, rhs > lhs which would mean there would need to be
+	// an extra allocation
+	Array(Operand) operands;
+	array_init_reserve(&operands, c->tmp_allocator, 2*lhs_count);
+
+	for_array(i, inits) {
+		AstNode *rhs = inits.e[i];
+		Operand o = {0};
+		check_multi_expr(c, &o, rhs);
+		if (o.type->kind != Type_Tuple) {
+			array_add(&operands, o);
+		} else {
+			TypeTuple *tuple = &o.type->Tuple;
+			for (isize j = 0; j < tuple->variable_count; j++) {
+				o.type = tuple->variables[j]->type;
+				array_add(&operands, o);
+			}
+		}
+	}
+
+	isize rhs_count = operands.count;
+	for_array(i, operands) {
+		if (operands.e[i].mode == Addressing_Invalid) {
+			rhs_count--;
+		}
+	}
+
+
+	isize max = gb_min(lhs_count, rhs_count);
+	for (isize i = 0; i < max; i++) {
+		check_init_variable(c, lhs[i], &operands.e[i], context_name);
+	}
+
+	if (rhs_count > 0 && lhs_count != rhs_count) {
+		error(lhs[0]->token, "Assignment count mismatch `%td` := `%td`", lhs_count, rhs_count);
+	}
+
+	gb_temp_arena_memory_end(tmp);
+}
+
+
+
+void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type, CycleChecker *cycle_checker) {
+	if (e->type != NULL) {
+		return;
+	}
+
+	if (d == NULL) {
+		DeclInfo **found = map_decl_info_get(&c->info.entities, hash_pointer(e));
+		if (found) {
+			d = *found;
+		} else {
+			e->type = t_invalid;
+			set_base_type(named_type, t_invalid);
+			return;
+			// GB_PANIC("`%.*s` should been declared!", LIT(e->token.string));
+		}
+	}
+
+	if (e->kind == Entity_Procedure) {
+		check_proc_decl(c, e, d);
+		return;
+	}
+	CheckerContext prev = c->context;
+	c->context.scope = d->scope;
+	c->context.decl  = d;
+
+	switch (e->kind) {
+	case Entity_Constant:
+		check_const_decl(c, e, d->type_expr, d->init_expr);
+		break;
+	case Entity_Variable:
+		check_var_decl(c, e, d->entities, d->entity_count, d->type_expr, d->init_expr);
+		break;
+	case Entity_TypeName:
+		check_type_decl(c, e, d->type_expr, named_type, cycle_checker);
+		break;
+	}
+
+	c->context = prev;
+}
+
+
+
+void check_var_decl_node(Checker *c, AstNode *node) {
+	ast_node(vd, VarDecl, node);
+	isize entity_count = vd->names.count;
+	isize entity_index = 0;
+	Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_count);
+
+	for_array(i, vd->names) {
+		AstNode *name = vd->names.e[i];
+		Entity *entity = NULL;
+		if (name->kind == AstNode_Ident) {
+			Token token = name->Ident;
+			String str = token.string;
+			Entity *found = NULL;
+			// NOTE(bill): Ignore assignments to `_`
+			if (str_ne(str, str_lit("_"))) {
+				found = current_scope_lookup_entity(c->context.scope, str);
+			}
+			if (found == NULL) {
+				entity = make_entity_variable(c->allocator, c->context.scope, token, NULL);
+				add_entity_definition(&c->info, name, entity);
+			} else {
+				TokenPos pos = found->token.pos;
+				error(token,
+				      "Redeclaration of `%.*s` in this scope\n"
+				      "\tat %.*s(%td:%td)",
+				      LIT(str), LIT(pos.file), pos.line, pos.column);
+				entity = found;
+			}
+		} else {
+			error(ast_node_token(name), "A variable declaration must be an identifier");
+		}
+		if (entity == NULL) {
+			entity = make_entity_dummy_variable(c->allocator, c->global_scope, ast_node_token(name));
+		}
+		entities[entity_index++] = entity;
+	}
+
+	Type *init_type = NULL;
+	if (vd->type) {
+		init_type = check_type_extra(c, vd->type, NULL, NULL);
+		if (init_type == NULL)
+			init_type = t_invalid;
+	}
+
+	for (isize i = 0; i < entity_count; i++) {
+		Entity *e = entities[i];
+		GB_ASSERT(e != NULL);
+		if (e->flags & EntityFlag_Visited) {
+			e->type = t_invalid;
+			continue;
+		}
+		e->flags |= EntityFlag_Visited;
+
+		if (e->type == NULL)
+			e->type = init_type;
+	}
+
+	check_init_variables(c, entities, entity_count, vd->values, str_lit("variable declaration"));
+
+	for_array(i, vd->names) {
+		if (entities[i] != NULL) {
+			add_entity(c, c->context.scope, vd->names.e[i], entities[i]);
+		}
+	}
+
+}
+
+
+
+void check_init_constant(Checker *c, Entity *e, Operand *operand) {
+	if (operand->mode == Addressing_Invalid ||
+	    operand->type == t_invalid ||
+	    e->type == t_invalid) {
+		if (e->type == NULL) {
+			e->type = t_invalid;
+		}
+		return;
+	}
+
+	if (operand->mode != Addressing_Constant) {
+		// TODO(bill): better error
+		error(ast_node_token(operand->expr),
+		      "`%.*s` is not a constant", LIT(ast_node_token(operand->expr).string));
+		if (e->type == NULL) {
+			e->type = t_invalid;
+		}
+		return;
+	}
+	// if (!is_type_constant_type(operand->type)) {
+	// 	gbString type_str = type_to_string(operand->type);
+	// 	defer (gb_string_free(type_str));
+	// 	error(ast_node_token(operand->expr),
+	// 	      "Invalid constant type: `%s`", type_str);
+	// 	if (e->type == NULL) {
+	// 		e->type = t_invalid;
+	// 	}
+	// 	return;
+	// }
+
+	if (e->type == NULL) { // NOTE(bill): type inference
+		e->type = operand->type;
+	}
+
+	check_assignment(c, operand, e->type, str_lit("constant declaration"));
+	if (operand->mode == Addressing_Invalid) {
+		return;
+	}
+
+	e->Constant.value = operand->value;
+}
+
+
+void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init_expr) {
+	GB_ASSERT(e->type == NULL);
+
+	if (e->flags & EntityFlag_Visited) {
+		e->type = t_invalid;
+		return;
+	}
+	e->flags |= EntityFlag_Visited;
+
+	if (type_expr) {
+		Type *t = check_type(c, type_expr);
+		// if (!is_type_constant_type(t)) {
+		// 	gbString str = type_to_string(t);
+		// 	defer (gb_string_free(str));
+		// 	error(ast_node_token(type_expr),
+		// 	      "Invalid constant type `%s`", str);
+		// 	e->type = t_invalid;
+		// 	return;
+		// }
+		e->type = t;
+	}
+
+	Operand operand = {0};
+	if (init_expr) {
+		check_expr(c, &operand, init_expr);
+	}
+	check_init_constant(c, e, &operand);
+}
+
+void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def, CycleChecker *cycle_checker) {
+	GB_ASSERT(e->type == NULL);
+	Type *named = make_type_named(c->allocator, e->token.string, NULL, e);
+	named->Named.type_name = e;
+	if (def != NULL && def->kind == Type_Named) {
+		def->Named.base = named;
+	}
+	e->type = named;
+
+	CycleChecker local_cycle_checker = {0};
+	if (cycle_checker == NULL) {
+		cycle_checker = &local_cycle_checker;
+	}
+
+	Type *bt = check_type_extra(c, type_expr, named, cycle_checker_add(cycle_checker, e));
+	named->Named.base = bt;
+	named->Named.base = base_type(named->Named.base);
+	if (named->Named.base == t_invalid) {
+		gb_printf("check_type_decl: %s\n", type_to_string(named));
+	}
+
+	cycle_checker_destroy(&local_cycle_checker);
+}
+
+
+bool are_signatures_similar_enough(Type *a_, Type *b_) {
+	GB_ASSERT(a_->kind == Type_Proc);
+	GB_ASSERT(b_->kind == Type_Proc);
+	TypeProc *a = &a_->Proc;
+	TypeProc *b = &b_->Proc;
+
+	if (a->param_count != b->param_count) {
+		return false;
+	}
+	if (a->result_count != b->result_count) {
+		return false;
+	}
+	for (isize i = 0; i < a->param_count; i++) {
+		Type *x = base_type(a->params->Tuple.variables[i]->type);
+		Type *y = base_type(b->params->Tuple.variables[i]->type);
+		if (is_type_pointer(x) && is_type_pointer(y)) {
+			continue;
+		}
+
+		if (!are_types_identical(x, y)) {
+			return false;
+		}
+	}
+	for (isize i = 0; i < a->result_count; i++) {
+		Type *x = base_type(a->results->Tuple.variables[i]->type);
+		Type *y = base_type(b->results->Tuple.variables[i]->type);
+		if (is_type_pointer(x) && is_type_pointer(y)) {
+			continue;
+		}
+
+		if (!are_types_identical(x, y)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) {
+	GB_ASSERT(e->type == NULL);
+
+	Type *proc_type = make_type_proc(c->allocator, e->scope, NULL, 0, NULL, 0, false);
+	e->type = proc_type;
+	ast_node(pd, ProcDecl, d->proc_decl);
+
+	check_open_scope(c, pd->type);
+	check_procedure_type(c, proc_type, pd->type);
+
+	bool is_foreign      = (pd->tags & ProcTag_foreign)   != 0;
+	bool is_link_name    = (pd->tags & ProcTag_link_name) != 0;
+	bool is_inline       = (pd->tags & ProcTag_inline)    != 0;
+	bool is_no_inline    = (pd->tags & ProcTag_no_inline) != 0;
+
+	if ((d->scope->is_file || d->scope->is_global) &&
+	    str_eq(e->token.string, str_lit("main"))) {
+		if (proc_type != NULL) {
+			TypeProc *pt = &proc_type->Proc;
+			if (pt->param_count != 0 ||
+			    pt->result_count) {
+				gbString str = type_to_string(proc_type);
+				error(e->token,
+				      "Procedure type of `main` was expected to be `proc()`, got %s", str);
+				gb_string_free(str);
+			}
+		}
+	}
+
+	if (is_inline && is_no_inline) {
+		error(ast_node_token(pd->type),
+		      "You cannot apply both `inline` and `no_inline` to a procedure");
+	}
+
+	if (is_foreign && is_link_name) {
+		error(ast_node_token(pd->type),
+		      "You cannot apply both `foreign` and `link_name` to a procedure");
+	}
+
+	if (pd->body != NULL) {
+		if (is_foreign) {
+			error(ast_node_token(pd->body),
+			      "A procedure tagged as `#foreign` cannot have a body");
+		}
+
+		d->scope = c->context.scope;
+
+		GB_ASSERT(pd->body->kind == AstNode_BlockStmt);
+		check_procedure_later(c, c->curr_ast_file, e->token, d, proc_type, pd->body, pd->tags);
+	}
+
+	if (is_foreign) {
+		MapEntity *fp = &c->info.foreign_procs;
+		AstNodeProcDecl *proc_decl = &d->proc_decl->ProcDecl;
+		String name = proc_decl->name->Ident.string;
+		if (proc_decl->foreign_name.len > 0) {
+			name = proc_decl->foreign_name;
+		}
+		HashKey key = hash_string(name);
+		Entity **found = map_entity_get(fp, key);
+		if (found) {
+			Entity *f = *found;
+			TokenPos pos = f->token.pos;
+			Type *this_type = base_type(e->type);
+			Type *other_type = base_type(f->type);
+			if (!are_signatures_similar_enough(this_type, other_type)) {
+				error(ast_node_token(d->proc_decl),
+				      "Redeclaration of #foreign procedure `%.*s` with different type signatures\n"
+				      "\tat %.*s(%td:%td)",
+				      LIT(name), LIT(pos.file), pos.line, pos.column);
+			}
+		} else {
+			map_entity_set(fp, key, e);
+		}
+	} else if (is_link_name) {
+		MapEntity *fp = &c->info.foreign_procs;
+		AstNodeProcDecl *proc_decl = &d->proc_decl->ProcDecl;
+		String name = proc_decl->link_name;
+
+		HashKey key = hash_string(name);
+		Entity **found = map_entity_get(fp, key);
+		if (found) {
+			Entity *f = *found;
+			TokenPos pos = f->token.pos;
+			error(ast_node_token(d->proc_decl),
+			      "Non unique #link_name for procedure `%.*s`\n"
+			      "\tother at %.*s(%td:%td)",
+			      LIT(name), LIT(pos.file), pos.line, pos.column);
+		} else {
+			map_entity_set(fp, key, e);
+		}
+	}
+
+	check_close_scope(c);
+}
+
+void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count, AstNode *type_expr, AstNode *init_expr) {
+	GB_ASSERT(e->type == NULL);
+	GB_ASSERT(e->kind == Entity_Variable);
+
+	if (e->flags & EntityFlag_Visited) {
+		e->type = t_invalid;
+		return;
+	}
+	e->flags |= EntityFlag_Visited;
+
+	if (type_expr != NULL)
+		e->type = check_type_extra(c, type_expr, NULL, NULL);
+
+	if (init_expr == NULL) {
+		if (type_expr == NULL)
+			e->type = t_invalid;
+		return;
+	}
+
+	if (entities == NULL || entity_count == 1) {
+		GB_ASSERT(entities == NULL || entities[0] == e);
+		Operand operand = {0};
+		check_expr(c, &operand, init_expr);
+		check_init_variable(c, e, &operand, str_lit("variable declaration"));
+	}
+
+	if (type_expr != NULL) {
+		for (isize i = 0; i < entity_count; i++)
+			entities[i]->type = e->type;
+	}
+
+	AstNodeArray inits;
+	array_init_reserve(&inits, c->allocator, 1);
+	array_add(&inits, init_expr);
+	check_init_variables(c, entities, entity_count, inits, str_lit("variable declaration"));
+}
+
+void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNode *body) {
+	GB_ASSERT(body->kind == AstNode_BlockStmt);
+
+	CheckerContext old_context = c->context;
+	c->context.scope = decl->scope;
+	c->context.decl = decl;
+
+	GB_ASSERT(type->kind == Type_Proc);
+	if (type->Proc.param_count > 0) {
+		TypeTuple *params = &type->Proc.params->Tuple;
+		for (isize i = 0; i < params->variable_count; i++) {
+			Entity *e = params->variables[i];
+			GB_ASSERT(e->kind == Entity_Variable);
+			if (!(e->flags & EntityFlag_Anonymous)) {
+				continue;
+			}
+			String name = e->token.string;
+			Type *t = base_type(type_deref(e->type));
+			if (is_type_struct(t) || is_type_raw_union(t)) {
+				Scope **found = map_scope_get(&c->info.scopes, hash_pointer(t->Record.node));
+				GB_ASSERT(found != NULL);
+				for_array(i, (*found)->elements.entries) {
+					Entity *f = (*found)->elements.entries.e[i].value;
+					if (f->kind == Entity_Variable) {
+						Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type);
+						Entity *prev = scope_insert_entity(c->context.scope, uvar);
+						if (prev != NULL) {
+							error(e->token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string));
+							break;
+						}
+					}
+				}
+			} else {
+				error(e->token, "`using` can only be applied to variables of type struct or raw_union");
+				break;
+			}
+		}
+	}
+
+	push_procedure(c, type);
+	{
+		ast_node(bs, BlockStmt, body);
+		// TODO(bill): Check declarations first (except mutable variable declarations)
+		check_stmt_list(c, bs->stmts, 0);
+		if (type->Proc.result_count > 0) {
+			if (!check_is_terminating(body)) {
+				error(bs->close, "Missing return statement at the end of the procedure");
+			}
+		}
+	}
+	pop_procedure(c);
+
+
+	check_scope_usage(c, c->context.scope);
+
+	c->context = old_context;
+}
+
+
+
@@ -0,0 +1,179 @@
+typedef struct Scope Scope;
+typedef struct Checker Checker;
+typedef struct Type Type;
+typedef enum BuiltinProcId BuiltinProcId;
+typedef enum ImplicitValueId ImplicitValueId;
+
+#define ENTITY_KINDS \
+	ENTITY_KIND(Invalid) \
+	ENTITY_KIND(Constant) \
+	ENTITY_KIND(Variable) \
+	ENTITY_KIND(TypeName) \
+	ENTITY_KIND(Procedure) \
+	ENTITY_KIND(Builtin) \
+	ENTITY_KIND(ImportName) \
+	ENTITY_KIND(Nil) \
+	ENTITY_KIND(ImplicitValue) \
+	ENTITY_KIND(Count)
+
+typedef enum EntityKind {
+#define ENTITY_KIND(k) GB_JOIN2(Entity_, k),
+	ENTITY_KINDS
+#undef ENTITY_KIND
+} EntityKind;
+
+String const entity_strings[] = {
+#define ENTITY_KIND(k) {cast(u8 *)#k, gb_size_of(#k)-1},
+	ENTITY_KINDS
+#undef ENTITY_KIND
+};
+
+typedef enum EntityFlag {
+	EntityFlag_Visited    = 1<<0,
+	EntityFlag_Used       = 1<<1,
+	EntityFlag_Anonymous  = 1<<2,
+	EntityFlag_Field      = 1<<3,
+	EntityFlag_Param      = 1<<4,
+	EntityFlag_VectorElem = 1<<5,
+} EntityFlag;
+
+typedef struct Entity Entity;
+struct Entity {
+	EntityKind kind;
+	u32        flags;
+	Token      token;
+	Scope *    scope;
+	Type *     type;
+	AstNode *  identifier; // Can be NULL
+
+	// TODO(bill): Cleanup how `using` works for entities
+	Entity *   using_parent;
+	AstNode *  using_expr;
+
+	union {
+		struct {
+			ExactValue value;
+		} Constant;
+		struct {
+			i32 field_index;
+			i32 field_src_index;
+		} Variable;
+		i32 TypeName;
+		i32 Procedure;
+		struct {
+			BuiltinProcId id;
+		} Builtin;
+		struct {
+			String path;
+			String name;
+			Scope *scope;
+			bool    used;
+		} ImportName;
+		i32 Nil;
+		struct {
+			// TODO(bill): Should this be a user-level construct rather than compiler-level?
+			ImplicitValueId id;
+			Entity *        backing;
+		} ImplicitValue;
+	};
+};
+
+Entity *alloc_entity(gbAllocator a, EntityKind kind, Scope *scope, Token token, Type *type) {
+	Entity *entity = gb_alloc_item(a, Entity);
+	entity->kind   = kind;
+	entity->scope  = scope;
+	entity->token  = token;
+	entity->type   = type;
+	return entity;
+}
+
+Entity *make_entity_variable(gbAllocator a, Scope *scope, Token token, Type *type) {
+	Entity *entity = alloc_entity(a, Entity_Variable, scope, token, type);
+	return entity;
+}
+
+Entity *make_entity_using_variable(gbAllocator a, Entity *parent, Token token, Type *type) {
+	GB_ASSERT(parent != NULL);
+	Entity *entity = alloc_entity(a, Entity_Variable, parent->scope, token, type);
+	entity->using_parent = parent;
+	entity->flags |= EntityFlag_Anonymous;
+	return entity;
+}
+
+
+Entity *make_entity_constant(gbAllocator a, Scope *scope, Token token, Type *type, ExactValue value) {
+	Entity *entity = alloc_entity(a, Entity_Constant, scope, token, type);
+	entity->Constant.value = value;
+	return entity;
+}
+
+Entity *make_entity_type_name(gbAllocator a, Scope *scope, Token token, Type *type) {
+	Entity *entity = alloc_entity(a, Entity_TypeName, scope, token, type);
+	return entity;
+}
+
+Entity *make_entity_param(gbAllocator a, Scope *scope, Token token, Type *type, bool anonymous) {
+	Entity *entity = make_entity_variable(a, scope, token, type);
+	entity->flags |= EntityFlag_Used;
+	entity->flags |= EntityFlag_Anonymous*(anonymous != 0);
+	entity->flags |= EntityFlag_Param;
+	return entity;
+}
+
+Entity *make_entity_field(gbAllocator a, Scope *scope, Token token, Type *type, bool anonymous, i32 field_src_index) {
+	Entity *entity = make_entity_variable(a, scope, token, type);
+	entity->Variable.field_src_index = field_src_index;
+	entity->Variable.field_index = field_src_index;
+	entity->flags |= EntityFlag_Field;
+	entity->flags |= EntityFlag_Anonymous*(anonymous != 0);
+	return entity;
+}
+
+Entity *make_entity_vector_elem(gbAllocator a, Scope *scope, Token token, Type *type, i32 field_src_index) {
+	Entity *entity = make_entity_variable(a, scope, token, type);
+	entity->Variable.field_src_index = field_src_index;
+	entity->Variable.field_index = field_src_index;
+	entity->flags |= EntityFlag_Field;
+	entity->flags |= EntityFlag_VectorElem;
+	return entity;
+}
+
+Entity *make_entity_procedure(gbAllocator a, Scope *scope, Token token, Type *signature_type) {
+	Entity *entity = alloc_entity(a, Entity_Procedure, scope, token, signature_type);
+	return entity;
+}
+
+Entity *make_entity_builtin(gbAllocator a, Scope *scope, Token token, Type *type, BuiltinProcId id) {
+	Entity *entity = alloc_entity(a, Entity_Builtin, scope, token, type);
+	entity->Builtin.id = id;
+	return entity;
+}
+
+Entity *make_entity_import_name(gbAllocator a, Scope *scope, Token token, Type *type,
+                                String path, String name, Scope *import_scope) {
+	Entity *entity = alloc_entity(a, Entity_ImportName, scope, token, type);
+	entity->ImportName.path = path;
+	entity->ImportName.name = name;
+	entity->ImportName.scope = import_scope;
+	return entity;
+}
+
+Entity *make_entity_nil(gbAllocator a, String name, Type *type) {
+	Token token = make_token_ident(name);
+	Entity *entity = alloc_entity(a, Entity_Nil, NULL, token, type);
+	return entity;
+}
+
+Entity *make_entity_implicit_value(gbAllocator a, String name, Type *type, ImplicitValueId id) {
+	Token token = make_token_ident(name);
+	Entity *entity = alloc_entity(a, Entity_ImplicitValue, NULL, token, type);
+	entity->ImplicitValue.id = id;
+	return entity;
+}
+
+
+Entity *make_entity_dummy_variable(gbAllocator a, Scope *file_scope, Token token) {
+	token.string = str_lit("_");
+	return make_entity_variable(a, file_scope, token, NULL);
+}
+