Add `gb_internal` to checker

1 files changed, 196 insertions, 197 deletions

diff --git a/src/checker.cpp b/src/checker.cpp
index d5222f615..e2c430dc2 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -1,12 +1,12 @@
 #include "entity.cpp"
 #include "types.cpp"
 
-void check_expr(CheckerContext *c, Operand *operand, Ast *expression);
-void check_expr_or_type(CheckerContext *c, Operand *operand, Ast *expression, Type *type_hint=nullptr);
-void add_comparison_procedures_for_fields(CheckerContext *c, Type *t);
-Type *check_type(CheckerContext *ctx, Ast *e);
+gb_internal void check_expr(CheckerContext *c, Operand *operand, Ast *expression);
+gb_internal void check_expr_or_type(CheckerContext *c, Operand *operand, Ast *expression, Type *type_hint=nullptr);
+gb_internal void add_comparison_procedures_for_fields(CheckerContext *c, Type *t);
+gb_internal Type *check_type(CheckerContext *ctx, Ast *e);
 
-bool is_operand_value(Operand o) {
+gb_internal bool is_operand_value(Operand o) {
 	switch (o.mode) {
 	case Addressing_Value:
 	case Addressing_Context:
@@ -22,14 +22,14 @@ bool is_operand_value(Operand o) {
 	}
 	return false;
 }
-bool is_operand_nil(Operand o) {
+gb_internal bool is_operand_nil(Operand o) {
 	return o.mode == Addressing_Value && o.type == t_untyped_nil;
 }
-bool is_operand_undef(Operand o) {
+gb_internal bool is_operand_undef(Operand o) {
 	return o.mode == Addressing_Value && o.type == t_untyped_undef;
 }
 
-bool check_rtti_type_disallowed(Token const &token, Type *type, char const *format) {
+gb_internal bool check_rtti_type_disallowed(Token const &token, Type *type, char const *format) {
 	if (build_context.disallow_rtti && type) {
 		if (is_type_any(type)) {
 			gbString t = type_to_string(type);
@@ -41,12 +41,12 @@ bool check_rtti_type_disallowed(Token const &token, Type *type, char const *form
 	return false;
 }
 
-bool check_rtti_type_disallowed(Ast *expr, Type *type, char const *format) {
+gb_internal bool check_rtti_type_disallowed(Ast *expr, Type *type, char const *format) {
 	GB_ASSERT(expr != nullptr);
 	return check_rtti_type_disallowed(ast_token(expr), type, format);
 }
 
-void scope_reset(Scope *scope) {
+gb_internal void scope_reset(Scope *scope) {
 	if (scope == nullptr) return;
 
 	scope->head_child.store(nullptr, std::memory_order_relaxed);
@@ -54,14 +54,14 @@ void scope_reset(Scope *scope) {
 	ptr_set_clear(&scope->imported);
 }
 
-void scope_reserve(Scope *scope, isize capacity) {
+gb_internal void scope_reserve(Scope *scope, isize capacity) {
 	isize cap = 2*capacity;
 	if (cap > scope->elements.hashes.count) {
 		string_map_rehash(&scope->elements, capacity);
 	}
 }
 
-i32 is_scope_an_ancestor(Scope *parent, Scope *child) {
+gb_internal i32 is_scope_an_ancestor(Scope *parent, Scope *child) {
 	i32 i = 0;
 	while (child != nullptr) {
 		if (parent == child) {
@@ -73,35 +73,35 @@ i32 is_scope_an_ancestor(Scope *parent, Scope *child) {
 	return -1;
 }
 
-void entity_graph_node_set_destroy(EntityGraphNodeSet *s) {
+gb_internal void entity_graph_node_set_destroy(EntityGraphNodeSet *s) {
 	if (s->hashes.data != nullptr) {
 		ptr_set_destroy(s);
 	}
 }
 
-void entity_graph_node_set_add(EntityGraphNodeSet *s, EntityGraphNode *n) {
+gb_internal void entity_graph_node_set_add(EntityGraphNodeSet *s, EntityGraphNode *n) {
 	if (s->hashes.data == nullptr) {
 		ptr_set_init(s, heap_allocator());
 	}
 	ptr_set_add(s, n);
 }
 
-bool entity_graph_node_set_exists(EntityGraphNodeSet *s, EntityGraphNode *n) {
+gb_internal bool entity_graph_node_set_exists(EntityGraphNodeSet *s, EntityGraphNode *n) {
 	return ptr_set_exists(s, n);
 }
 
-void entity_graph_node_set_remove(EntityGraphNodeSet *s, EntityGraphNode *n) {
+gb_internal void entity_graph_node_set_remove(EntityGraphNodeSet *s, EntityGraphNode *n) {
 	ptr_set_remove(s, n);
 }
 
-void entity_graph_node_destroy(EntityGraphNode *n, gbAllocator a) {
+gb_internal void entity_graph_node_destroy(EntityGraphNode *n, gbAllocator a) {
 	entity_graph_node_set_destroy(&n->pred);
 	entity_graph_node_set_destroy(&n->succ);
 	gb_free(a, n);
 }
 
 
-int entity_graph_node_cmp(EntityGraphNode **data, isize i, isize j) {
+gb_internal int entity_graph_node_cmp(EntityGraphNode **data, isize i, isize j) {
 	EntityGraphNode *x = data[i];
 	EntityGraphNode *y = data[j];
 	u64 a = x->entity->order_in_src;
@@ -115,7 +115,7 @@ int entity_graph_node_cmp(EntityGraphNode **data, isize i, isize j) {
 	return +1;
 }
 
-void entity_graph_node_swap(EntityGraphNode **data, isize i, isize j) {
+gb_internal void entity_graph_node_swap(EntityGraphNode **data, isize i, isize j) {
 	EntityGraphNode *x = data[i];
 	EntityGraphNode *y = data[j];
 	data[i] = y;
@@ -126,42 +126,42 @@ void entity_graph_node_swap(EntityGraphNode **data, isize i, isize j) {
 
 
 
-void import_graph_node_set_destroy(ImportGraphNodeSet *s) {
+gb_internal void import_graph_node_set_destroy(ImportGraphNodeSet *s) {
 	if (s->hashes.data != nullptr) {
 		ptr_set_destroy(s);
 	}
 }
 
-void import_graph_node_set_add(ImportGraphNodeSet *s, ImportGraphNode *n) {
+gb_internal void import_graph_node_set_add(ImportGraphNodeSet *s, ImportGraphNode *n) {
 	if (s->hashes.data == nullptr) {
 		ptr_set_init(s, heap_allocator());
 	}
 	ptr_set_add(s, n);
 }
 
-bool import_graph_node_set_exists(ImportGraphNodeSet *s, ImportGraphNode *n) {
+gb_internal bool import_graph_node_set_exists(ImportGraphNodeSet *s, ImportGraphNode *n) {
 	return ptr_set_exists(s, n);
 }
 
-void import_graph_node_set_remove(ImportGraphNodeSet *s, ImportGraphNode *n) {
+gb_internal void import_graph_node_set_remove(ImportGraphNodeSet *s, ImportGraphNode *n) {
 	ptr_set_remove(s, n);
 }
 
-ImportGraphNode *import_graph_node_create(gbAllocator a, AstPackage *pkg) {
+gb_internal ImportGraphNode *import_graph_node_create(gbAllocator a, AstPackage *pkg) {
 	ImportGraphNode *n = gb_alloc_item(a, ImportGraphNode);
 	n->pkg = pkg;
 	n->scope = pkg->scope;
 	return n;
 }
 
-void import_graph_node_destroy(ImportGraphNode *n, gbAllocator a) {
+gb_internal void import_graph_node_destroy(ImportGraphNode *n, gbAllocator a) {
 	import_graph_node_set_destroy(&n->pred);
 	import_graph_node_set_destroy(&n->succ);
 	gb_free(a, n);
 }
 
 
-int import_graph_node_cmp(ImportGraphNode **data, isize i, isize j) {
+gb_internal int import_graph_node_cmp(ImportGraphNode **data, isize i, isize j) {
 	ImportGraphNode *x = data[i];
 	ImportGraphNode *y = data[j];
 	GB_ASSERT(x != y);
@@ -177,7 +177,7 @@ int import_graph_node_cmp(ImportGraphNode **data, isize i, isize j) {
 	return 0;
 }
 
-void import_graph_node_swap(ImportGraphNode **data, isize i, isize j) {
+gb_internal void import_graph_node_swap(ImportGraphNode **data, isize i, isize j) {
 	ImportGraphNode *x = data[i];
 	ImportGraphNode *y = data[j];
 	data[i] = y;
@@ -186,7 +186,7 @@ void import_graph_node_swap(ImportGraphNode **data, isize i, isize j) {
 	y->index = i;
 }
 
-GB_COMPARE_PROC(ast_node_cmp) {
+gb_internal GB_COMPARE_PROC(ast_node_cmp) {
 	Ast *x = *cast(Ast **)a;
 	Ast *y = *cast(Ast **)b;
 	Token i = ast_token(x);
@@ -199,7 +199,7 @@ GB_COMPARE_PROC(ast_node_cmp) {
 
 
 
-void init_decl_info(DeclInfo *d, Scope *scope, DeclInfo *parent) {
+gb_internal void init_decl_info(DeclInfo *d, Scope *scope, DeclInfo *parent) {
 	d->parent = parent;
 	d->scope  = scope;
 	ptr_set_init(&d->deps,           heap_allocator());
@@ -207,18 +207,18 @@ void init_decl_info(DeclInfo *d, Scope *scope, DeclInfo *parent) {
 	array_init  (&d->labels,         heap_allocator());
 }
 
-DeclInfo *make_decl_info(Scope *scope, DeclInfo *parent) {
+gb_internal DeclInfo *make_decl_info(Scope *scope, DeclInfo *parent) {
 	DeclInfo *d = gb_alloc_item(permanent_allocator(), DeclInfo);
 	init_decl_info(d, scope, parent);
 	return d;
 }
 
-void destroy_declaration_info(DeclInfo *d) {
+gb_internal void destroy_declaration_info(DeclInfo *d) {
 	ptr_set_destroy(&d->deps);
 	array_free(&d->labels);
 }
 
-bool decl_info_has_init(DeclInfo *d) {
+gb_internal bool decl_info_has_init(DeclInfo *d) {
 	if (d->init_expr != nullptr) {
 		return true;
 	}
@@ -239,7 +239,7 @@ bool decl_info_has_init(DeclInfo *d) {
 
 
 
-Scope *create_scope(CheckerInfo *info, Scope *parent, isize init_elements_capacity=DEFAULT_SCOPE_CAPACITY) {
+gb_internal Scope *create_scope(CheckerInfo *info, Scope *parent, isize init_elements_capacity=DEFAULT_SCOPE_CAPACITY) {
 	Scope *s = gb_alloc_item(permanent_allocator(), Scope);
 	s->parent = parent;
 	string_map_init(&s->elements, heap_allocator(), init_elements_capacity);
@@ -260,7 +260,7 @@ Scope *create_scope(CheckerInfo *info, Scope *parent, isize init_elements_capaci
 	return s;
 }
 
-Scope *create_scope_from_file(CheckerInfo *info, AstFile *f) {
+gb_internal Scope *create_scope_from_file(CheckerInfo *info, AstFile *f) {
 	GB_ASSERT(f != nullptr);
 	GB_ASSERT(f->pkg != nullptr);
 	GB_ASSERT(f->pkg->scope != nullptr);
@@ -276,7 +276,7 @@ Scope *create_scope_from_file(CheckerInfo *info, AstFile *f) {
 	return s;
 }
 
-Scope *create_scope_from_package(CheckerContext *c, AstPackage *pkg) {
+gb_internal Scope *create_scope_from_package(CheckerContext *c, AstPackage *pkg) {
 	GB_ASSERT(pkg != nullptr);
 
 	isize total_pkg_decl_count = 0;
@@ -307,7 +307,7 @@ Scope *create_scope_from_package(CheckerContext *c, AstPackage *pkg) {
 	return s;
 }
 
-void destroy_scope(Scope *scope) {
+gb_internal void destroy_scope(Scope *scope) {
 	for (auto const &entry : scope->elements) {
 		Entity *e = entry.value;
 		if (e->kind == Entity_Variable) {
@@ -331,7 +331,7 @@ void destroy_scope(Scope *scope) {
 }
 
 
-void add_scope(CheckerContext *c, Ast *node, Scope *scope) {
+gb_internal void add_scope(CheckerContext *c, Ast *node, Scope *scope) {
 	GB_ASSERT(node != nullptr);
 	GB_ASSERT(scope != nullptr);
 	scope->node = node;
@@ -352,7 +352,7 @@ void add_scope(CheckerContext *c, Ast *node, Scope *scope) {
 	}
 }
 
-Scope *scope_of_node(Ast *node) {
+gb_internal Scope *scope_of_node(Ast *node) {
 	if (node == nullptr) {
 		return nullptr;
 	}
@@ -375,7 +375,7 @@ Scope *scope_of_node(Ast *node) {
 }
 
 
-void check_open_scope(CheckerContext *c, Ast *node) {
+gb_internal void check_open_scope(CheckerContext *c, Ast *node) {
 	node = unparen_expr(node);
 	GB_ASSERT(node->kind == Ast_Invalid ||
 	          is_ast_stmt(node) ||
@@ -397,12 +397,12 @@ void check_open_scope(CheckerContext *c, Ast *node) {
 	c->state_flags |= StateFlag_bounds_check;
 }
 
-void check_close_scope(CheckerContext *c) {
+gb_internal void check_close_scope(CheckerContext *c) {
 	c->scope = c->scope->parent;
 }
 
 
-Entity *scope_lookup_current(Scope *s, String const &name) {
+gb_internal Entity *scope_lookup_current(Scope *s, String const &name) {
 	Entity **found = string_map_get(&s->elements, name);
 	if (found) {
 		return *found;
@@ -410,7 +410,7 @@ Entity *scope_lookup_current(Scope *s, String const &name) {
 	return nullptr;
 }
 
-void scope_lookup_parent(Scope *scope, String const &name, Scope **scope_, Entity **entity_) {
+gb_internal void scope_lookup_parent(Scope *scope, String const &name, Scope **scope_, Entity **entity_) {
 	if (scope != nullptr) {
 		bool gone_thru_proc = false;
 		bool gone_thru_package = false;
@@ -455,7 +455,7 @@ void scope_lookup_parent(Scope *scope, String const &name, Scope **scope_, Entit
 	if (scope_) *scope_ = nullptr;
 }
 
-Entity *scope_lookup(Scope *s, String const &name) {
+gb_internal Entity *scope_lookup(Scope *s, String const &name) {
 	Entity *entity = nullptr;
 	scope_lookup_parent(s, name, nullptr, &entity);
 	return entity;
@@ -463,7 +463,7 @@ Entity *scope_lookup(Scope *s, String const &name) {
 
 
 
-Entity *scope_insert_with_name(Scope *s, String const &name, Entity *entity, bool use_mutex=true) {
+gb_internal Entity *scope_insert_with_name(Scope *s, String const &name, Entity *entity, bool use_mutex=true) {
 	if (name == "") {
 		return nullptr;
 	}
@@ -502,7 +502,7 @@ end:;
 	return result;
 }
 
-Entity *scope_insert(Scope *s, Entity *entity, bool use_mutex) {
+gb_internal Entity *scope_insert(Scope *s, Entity *entity, bool use_mutex) {
 	String name = entity->token.string;
 	return scope_insert_with_name(s, name, entity, use_mutex);
 }
@@ -528,14 +528,14 @@ struct VettedEntity {
 	Entity *entity;
 	Entity *other;
 };
-void init_vetted_entity(VettedEntity *ve, VettedEntityKind kind, Entity *entity, Entity *other=nullptr)  {
+gb_internal void init_vetted_entity(VettedEntity *ve, VettedEntityKind kind, Entity *entity, Entity *other=nullptr)  {
 	ve->kind = kind;
 	ve->entity = entity;
 	ve->other = other;
 }
 
 
-GB_COMPARE_PROC(vetted_entity_variable_pos_cmp) {
+gb_internal GB_COMPARE_PROC(vetted_entity_variable_pos_cmp) {
 	Entity *x = (cast(VettedEntity *)a)->entity;
 	Entity *y = (cast(VettedEntity *)b)->entity;
 	GB_ASSERT(x != nullptr);
@@ -544,7 +544,7 @@ GB_COMPARE_PROC(vetted_entity_variable_pos_cmp) {
 	return token_pos_cmp(x->token.pos, y->token.pos);
 }
 
-bool check_vet_shadowing_assignment(Checker *c, Entity *shadowed, Ast *expr) {
+gb_internal bool check_vet_shadowing_assignment(Checker *c, Entity *shadowed, Ast *expr) {
 	Ast *init = unparen_expr(expr);
 	if (init == nullptr) {
 		return false;
@@ -568,7 +568,7 @@ bool check_vet_shadowing_assignment(Checker *c, Entity *shadowed, Ast *expr) {
 }
 
 
-bool check_vet_shadowing(Checker *c, Entity *e, VettedEntity *ve) {
+gb_internal bool check_vet_shadowing(Checker *c, Entity *e, VettedEntity *ve) {
 	if (e->kind != Entity_Variable) {
 		return false;
 	}
@@ -634,7 +634,7 @@ bool check_vet_shadowing(Checker *c, Entity *e, VettedEntity *ve) {
 	return true;
 }
 
-bool check_vet_unused(Checker *c, Entity *e, VettedEntity *ve) {
+gb_internal bool check_vet_unused(Checker *c, Entity *e, VettedEntity *ve) {
 	if ((e->flags&EntityFlag_Used) == 0) {
 		switch (e->kind) {
 		case Entity_Variable:
@@ -652,7 +652,7 @@ bool check_vet_unused(Checker *c, Entity *e, VettedEntity *ve) {
 	return false;
 }
 
-void check_scope_usage(Checker *c, Scope *scope) {
+gb_internal void check_scope_usage(Checker *c, Scope *scope) {
 	bool vet_unused = true;
 	bool vet_shadowing = true;
 
@@ -728,12 +728,12 @@ void check_scope_usage(Checker *c, Scope *scope) {
 }
 
 
-void add_dependency(CheckerInfo *info, DeclInfo *d, Entity *e) {
+gb_internal void add_dependency(CheckerInfo *info, DeclInfo *d, Entity *e) {
 	mutex_lock(&info->deps_mutex);
 	ptr_set_add(&d->deps, e);
 	mutex_unlock(&info->deps_mutex);
 }
-void add_type_info_dependency(CheckerInfo *info, DeclInfo *d, Type *type, bool require_mutex) {
+gb_internal void add_type_info_dependency(CheckerInfo *info, DeclInfo *d, Type *type, bool require_mutex) {
 	if (d == nullptr) {
 		return;
 	}
@@ -746,7 +746,7 @@ void add_type_info_dependency(CheckerInfo *info, DeclInfo *d, Type *type, bool r
 	}
 }
 
-AstPackage *get_core_package(CheckerInfo *info, String name) {
+gb_internal AstPackage *get_core_package(CheckerInfo *info, String name) {
 	gbAllocator a = heap_allocator();
 	String path = get_fullpath_core(a, name);
 	defer (gb_free(a, path.text));
@@ -764,7 +764,7 @@ AstPackage *get_core_package(CheckerInfo *info, String name) {
 }
 
 
-void add_package_dependency(CheckerContext *c, char const *package_name, char const *name) {
+gb_internal void add_package_dependency(CheckerContext *c, char const *package_name, char const *name) {
 	String n = make_string_c(name);
 	AstPackage *p = get_core_package(&c->checker->info, make_string_c(package_name));
 	Entity *e = scope_lookup(p->scope, n);
@@ -774,7 +774,7 @@ void add_package_dependency(CheckerContext *c, char const *package_name, char co
 	add_dependency(c->info, c->decl, e);
 }
 
-void try_to_add_package_dependency(CheckerContext *c, char const *package_name, char const *name) {
+gb_internal void try_to_add_package_dependency(CheckerContext *c, char const *package_name, char const *name) {
 	String n = make_string_c(name);
 	AstPackage *p = get_core_package(&c->checker->info, make_string_c(package_name));
 	Entity *e = scope_lookup(p->scope, n);
@@ -787,7 +787,7 @@ void try_to_add_package_dependency(CheckerContext *c, char const *package_name,
 }
 
 
-void add_declaration_dependency(CheckerContext *c, Entity *e) {
+gb_internal void add_declaration_dependency(CheckerContext *c, Entity *e) {
 	if (e == nullptr) {
 		return;
 	}
@@ -797,7 +797,7 @@ void add_declaration_dependency(CheckerContext *c, Entity *e) {
 }
 
 
-Entity *add_global_entity(Entity *entity, Scope *scope=builtin_pkg->scope) {
+gb_internal Entity *add_global_entity(Entity *entity, Scope *scope=builtin_pkg->scope) {
 	String name = entity->token.string;
 	defer (entity->state = EntityState_Resolved);
 
@@ -810,27 +810,27 @@ Entity *add_global_entity(Entity *entity, Scope *scope=builtin_pkg->scope) {
 	return entity;
 }
 
-void add_global_constant(char const *name, Type *type, ExactValue value) {
+gb_internal void add_global_constant(char const *name, Type *type, ExactValue value) {
 	Entity *entity = alloc_entity(Entity_Constant, nullptr, make_token_ident(name), type);
 	entity->Constant.value = value;
 	add_global_entity(entity);
 }
 
 
-void add_global_string_constant(char const *name, String const &value) {
+gb_internal void add_global_string_constant(char const *name, String const &value) {
 	add_global_constant(name, t_untyped_string, exact_value_string(value));
 }
 
-void add_global_bool_constant(char const *name, bool value) {
+gb_internal void add_global_bool_constant(char const *name, bool value) {
 	add_global_constant(name, t_untyped_bool, exact_value_bool(value));
 }
 
-void add_global_type_entity(String name, Type *type) {
+gb_internal void add_global_type_entity(String name, Type *type) {
 	add_global_entity(alloc_entity_type_name(nullptr, make_token_ident(name), type));
 }
 
 
-AstPackage *create_builtin_package(char const *name) {
+gb_internal AstPackage *create_builtin_package(char const *name) {
 	gbAllocator a = permanent_allocator();
 	AstPackage *pkg = gb_alloc_item(a, AstPackage);
 	pkg->name = make_string_c(name);
@@ -847,7 +847,7 @@ struct GlobalEnumValue {
 	i64 value;
 };
 
-Slice<Entity *> add_global_enum_type(String const &type_name, GlobalEnumValue *values, isize value_count, Type **enum_type_ = nullptr) {
+gb_internal Slice<Entity *> add_global_enum_type(String const &type_name, GlobalEnumValue *values, isize value_count, Type **enum_type_ = nullptr) {
 	Scope *scope = create_scope(nullptr, builtin_pkg->scope);
 	Entity *entity = alloc_entity_type_name(scope, make_token_ident(type_name), nullptr, EntityState_Resolved);
 
@@ -882,7 +882,7 @@ Slice<Entity *> add_global_enum_type(String const &type_name, GlobalEnumValue *v
 
 	return slice_from_array(fields);
 }
-void add_global_enum_constant(Slice<Entity *> const &fields, char const *name, i64 value) {
+gb_internal void add_global_enum_constant(Slice<Entity *> const &fields, char const *name, i64 value) {
 	for (Entity *field : fields) {
 		GB_ASSERT(field->kind == Entity_Constant);
 		if (value == exact_value_to_i64(field->Constant.value)) {
@@ -893,7 +893,7 @@ void add_global_enum_constant(Slice<Entity *> const &fields, char const *name, i
 	GB_PANIC("Unfound enum value for global constant: %s %lld", name, cast(long long)value);
 }
 
-Type *add_global_type_name(Scope *scope, String const &type_name, Type *backing_type) {
+gb_internal Type *add_global_type_name(Scope *scope, String const &type_name, Type *backing_type) {
 	Entity *e = alloc_entity_type_name(scope, make_token_ident(type_name), nullptr, EntityState_Resolved);
 	Type *named_type = alloc_type_named(type_name, backing_type, e);
 	e->type = named_type;
@@ -905,7 +905,7 @@ Type *add_global_type_name(Scope *scope, String const &type_name, Type *backing_
 }
 
 
-void init_universal(void) {
+gb_internal void init_universal(void) {
 	BuildContext *bc = &build_context;
 
 	builtin_pkg    = create_builtin_package("builtin");
@@ -1122,7 +1122,7 @@ void init_universal(void) {
 
 
 
-void init_checker_info(CheckerInfo *i) {
+gb_internal void init_checker_info(CheckerInfo *i) {
 	gbAllocator a = heap_allocator();
 
 	TIME_SECTION("checker info: general");
@@ -1180,7 +1180,7 @@ void init_checker_info(CheckerInfo *i) {
 	string_map_init(&i->load_file_cache, a);
 }
 
-void destroy_checker_info(CheckerInfo *i) {
+gb_internal void destroy_checker_info(CheckerInfo *i) {
 	array_free(&i->definitions);
 	array_free(&i->entities);
 	map_destroy(&i->global_untyped);
@@ -1217,7 +1217,7 @@ void destroy_checker_info(CheckerInfo *i) {
 	string_map_destroy(&i->load_file_cache);
 }
 
-CheckerContext make_checker_context(Checker *c) {
+gb_internal CheckerContext make_checker_context(Checker *c) {
 	CheckerContext ctx = {};
 	ctx.checker   = c;
 	ctx.info      = &c->info;
@@ -1230,12 +1230,12 @@ CheckerContext make_checker_context(Checker *c) {
 	ctx.poly_level = 0;
 	return ctx;
 }
-void destroy_checker_context(CheckerContext *ctx) {
+gb_internal void destroy_checker_context(CheckerContext *ctx) {
 	destroy_checker_type_path(ctx->type_path);
 	destroy_checker_poly_path(ctx->poly_path);
 }
 
-void add_curr_ast_file(CheckerContext *ctx, AstFile *file) {
+gb_internal void add_curr_ast_file(CheckerContext *ctx, AstFile *file) {
 	if (file != nullptr) {
 		ctx->file  = file;
 		ctx->decl  = file->pkg->decl_info;
@@ -1243,7 +1243,7 @@ void add_curr_ast_file(CheckerContext *ctx, AstFile *file) {
 		ctx->pkg   = file->pkg;
 	}
 }
-void reset_checker_context(CheckerContext *ctx, AstFile *file, UntypedExprInfoMap *untyped) {
+gb_internal void reset_checker_context(CheckerContext *ctx, AstFile *file, UntypedExprInfoMap *untyped) {
 	if (ctx == nullptr) {
 		return;
 	}
@@ -1258,7 +1258,7 @@ void reset_checker_context(CheckerContext *ctx, AstFile *file, UntypedExprInfoMa
 
 
 
-void init_checker(Checker *c) {
+gb_internal void init_checker(Checker *c) {
 	gbAllocator a = heap_allocator();
 
 	TIME_SECTION("init checker info");
@@ -1278,7 +1278,7 @@ void init_checker(Checker *c) {
 	c->builtin_ctx = make_checker_context(c);
 }
 
-void destroy_checker(Checker *c) {
+gb_internal void destroy_checker(Checker *c) {
 	destroy_checker_info(&c->info);
 
 	destroy_checker_context(&c->builtin_ctx);
@@ -1290,7 +1290,7 @@ void destroy_checker(Checker *c) {
 }
 
 
-TypeAndValue type_and_value_of_expr(Ast *expr) {
+gb_internal TypeAndValue type_and_value_of_expr(Ast *expr) {
 	TypeAndValue tav = {};
 	if (expr != nullptr) {
 		tav = expr->tav;
@@ -1298,7 +1298,7 @@ TypeAndValue type_and_value_of_expr(Ast *expr) {
 	return tav;
 }
 
-Type *type_of_expr(Ast *expr) {
+gb_internal Type *type_of_expr(Ast *expr) {
 	TypeAndValue tav = expr->tav;
 	if (tav.mode != Addressing_Invalid) {
 		return tav.type;
@@ -1313,14 +1313,14 @@ Type *type_of_expr(Ast *expr) {
 	return nullptr;
 }
 
-Entity *implicit_entity_of_node(Ast *clause) {
+gb_internal Entity *implicit_entity_of_node(Ast *clause) {
 	if (clause != nullptr && clause->kind == Ast_CaseClause) {
 		return clause->CaseClause.implicit_entity;
 	}
 	return nullptr;
 }
 
-Entity *entity_of_node(Ast *expr) {
+gb_internal Entity *entity_of_node(Ast *expr) {
 	expr = unparen_expr(expr);
 	switch (expr->kind) {
 	case_ast_node(ident, Ident, expr);
@@ -1341,25 +1341,25 @@ Entity *entity_of_node(Ast *expr) {
 	return nullptr;
 }
 
-DeclInfo *decl_info_of_entity(Entity *e) {
+gb_internal DeclInfo *decl_info_of_entity(Entity *e) {
 	if (e != nullptr) {
 		return e->decl_info;
 	}
 	return nullptr;
 }
 
-DeclInfo *decl_info_of_ident(Ast *ident) {
+gb_internal DeclInfo *decl_info_of_ident(Ast *ident) {
 	return decl_info_of_entity(entity_of_node(ident));
 }
 
-AstFile *ast_file_of_filename(CheckerInfo *i, String filename) {
+gb_internal AstFile *ast_file_of_filename(CheckerInfo *i, String filename) {
 	AstFile **found = string_map_get(&i->files, filename);
 	if (found != nullptr) {
 		return *found;
 	}
 	return nullptr;
 }
-ExprInfo *check_get_expr_info(CheckerContext *c, Ast *expr) {
+gb_internal ExprInfo *check_get_expr_info(CheckerContext *c, Ast *expr) {
 	if (c->untyped != nullptr) {
 		ExprInfo **found = map_get(c->untyped, expr);
 		if (found) {
@@ -1377,7 +1377,7 @@ ExprInfo *check_get_expr_info(CheckerContext *c, Ast *expr) {
 	}
 }
 
-void check_set_expr_info(CheckerContext *c, Ast *expr, AddressingMode mode, Type *type, ExactValue value) {
+gb_internal void check_set_expr_info(CheckerContext *c, Ast *expr, AddressingMode mode, Type *type, ExactValue value) {
 	if (c->untyped != nullptr) {
 		map_set(c->untyped, expr, make_expr_info(mode, type, value, false));
 	} else {
@@ -1387,7 +1387,7 @@ void check_set_expr_info(CheckerContext *c, Ast *expr, AddressingMode mode, Type
 	}
 }
 
-void check_remove_expr_info(CheckerContext *c, Ast *e) {
+gb_internal void check_remove_expr_info(CheckerContext *c, Ast *e) {
 	if (c->untyped != nullptr) {
 		map_remove(c->untyped, e);
 		GB_ASSERT(map_get(c->untyped, e) == nullptr);
@@ -1401,7 +1401,7 @@ void check_remove_expr_info(CheckerContext *c, Ast *e) {
 }
 
 
-isize type_info_index(CheckerInfo *info, Type *type, bool error_on_failure) {
+gb_internal isize type_info_index(CheckerInfo *info, Type *type, bool error_on_failure) {
 	type = default_type(type);
 	if (type == t_llvm_bool) {
 		type = t_bool;
@@ -1436,7 +1436,7 @@ isize type_info_index(CheckerInfo *info, Type *type, bool error_on_failure) {
 }
 
 
-void add_untyped(CheckerContext *c, Ast *expr, AddressingMode mode, Type *type, ExactValue value) {
+gb_internal void add_untyped(CheckerContext *c, Ast *expr, AddressingMode mode, Type *type, ExactValue value) {
 	if (expr == nullptr) {
 		return;
 	}
@@ -1453,7 +1453,7 @@ void add_untyped(CheckerContext *c, Ast *expr, AddressingMode mode, Type *type,
 	check_set_expr_info(c, expr, mode, type, value);
 }
 
-void add_type_and_value(CheckerInfo *i, Ast *expr, AddressingMode mode, Type *type, ExactValue value) {
+gb_internal void add_type_and_value(CheckerInfo *i, Ast *expr, AddressingMode mode, Type *type, ExactValue value) {
 	if (expr == nullptr) {
 		return;
 	}
@@ -1489,7 +1489,7 @@ void add_type_and_value(CheckerInfo *i, Ast *expr, AddressingMode mode, Type *ty
 	mutex_unlock(&i->type_and_value_mutex);
 }
 
-void add_entity_definition(CheckerInfo *i, Ast *identifier, Entity *entity) {
+gb_internal void add_entity_definition(CheckerInfo *i, Ast *identifier, Entity *entity) {
 	GB_ASSERT(identifier != nullptr);
 	GB_ASSERT(identifier->kind == Ast_Ident);
 	// if (is_blank_ident(identifier)) {
@@ -1505,7 +1505,7 @@ void add_entity_definition(CheckerInfo *i, Ast *identifier, Entity *entity) {
 	mpmc_enqueue(&i->definition_queue, entity);
 }
 
-bool redeclaration_error(String name, Entity *prev, Entity *found) {
+gb_internal bool redeclaration_error(String name, Entity *prev, Entity *found) {
 	TokenPos pos = found->token.pos;
 	Entity *up = found->using_parent;
 	if (up != nullptr) {
@@ -1548,7 +1548,7 @@ bool redeclaration_error(String name, Entity *prev, Entity *found) {
 	return false;
 }
 
-void add_entity_flags_from_file(CheckerContext *c, Entity *e, Scope *scope) {
+gb_internal void add_entity_flags_from_file(CheckerContext *c, Entity *e, Scope *scope) {
 	if (c->file != nullptr && (c->file->flags & AstFile_IsLazy) != 0 && scope->flags & ScopeFlag_File) {
 		AstPackage *pkg = c->file->pkg;
 		if (pkg->kind == Package_Init && e->kind == Entity_Procedure && e->token.string == "main") {
@@ -1561,7 +1561,7 @@ void add_entity_flags_from_file(CheckerContext *c, Entity *e, Scope *scope) {
 	}
 }
 
-bool add_entity_with_name(CheckerContext *c, Scope *scope, Ast *identifier, Entity *entity, String name) {
+gb_internal bool add_entity_with_name(CheckerContext *c, Scope *scope, Ast *identifier, Entity *entity, String name) {
 	if (scope == nullptr) {
 		return false;
 	}
@@ -1581,11 +1581,11 @@ bool add_entity_with_name(CheckerContext *c, Scope *scope, Ast *identifier, Enti
 	}
 	return true;
 }
-bool add_entity(CheckerContext *c, Scope *scope, Ast *identifier, Entity *entity) {
+gb_internal bool add_entity(CheckerContext *c, Scope *scope, Ast *identifier, Entity *entity) {
 	return add_entity_with_name(c, scope, identifier, entity, entity->token.string);
 }
 
-void add_entity_use(CheckerContext *c, Ast *identifier, Entity *entity) {
+gb_internal void add_entity_use(CheckerContext *c, Ast *identifier, Entity *entity) {
 	if (entity == nullptr) {
 		return;
 	}
@@ -1622,7 +1622,7 @@ void add_entity_use(CheckerContext *c, Ast *identifier, Entity *entity) {
 }
 
 
-bool could_entity_be_lazy(Entity *e, DeclInfo *d) {
+gb_internal bool could_entity_be_lazy(Entity *e, DeclInfo *d) {
 	if ((e->flags & EntityFlag_Lazy) == 0) {
 		return false;
 	}
@@ -1673,7 +1673,7 @@ bool could_entity_be_lazy(Entity *e, DeclInfo *d) {
 	return true;
 }
 
-void add_entity_and_decl_info(CheckerContext *c, Ast *identifier, Entity *e, DeclInfo *d, bool is_exported) {
+gb_internal void add_entity_and_decl_info(CheckerContext *c, Ast *identifier, Entity *e, DeclInfo *d, bool is_exported) {
 	if (identifier == nullptr) {
 		// NOTE(bill): Should only happen on errors
 		error(e->token, "Invalid variable declaration");
@@ -1738,16 +1738,15 @@ void add_entity_and_decl_info(CheckerContext *c, Ast *identifier, Entity *e, Dec
 }
 
 
-void add_implicit_entity(CheckerContext *c, Ast *clause, Entity *e) {
+gb_internal void add_implicit_entity(CheckerContext *c, Ast *clause, Entity *e) {
 	GB_ASSERT(clause != nullptr);
 	GB_ASSERT(e != nullptr);
 	GB_ASSERT(clause->kind == Ast_CaseClause);
 	clause->CaseClause.implicit_entity = e;
 }
 
-void add_type_info_type(CheckerContext *c, Type *t) {
-	void add_type_info_type_internal(CheckerContext *c, Type *t);
-
+gb_internal void add_type_info_type_internal(CheckerContext *c, Type *t);
+gb_internal void add_type_info_type(CheckerContext *c, Type *t) {
 	if (build_context.disallow_rtti) {
 		return;
 	}
@@ -1757,7 +1756,7 @@ void add_type_info_type(CheckerContext *c, Type *t) {
 	mutex_unlock(&c->info->type_info_mutex);
 }
 
-void add_type_info_type_internal(CheckerContext *c, Type *t) {
+gb_internal void add_type_info_type_internal(CheckerContext *c, Type *t) {
 	if (t == nullptr) {
 		return;
 	}
@@ -1982,7 +1981,7 @@ void add_type_info_type_internal(CheckerContext *c, Type *t) {
 
 gb_global bool global_procedure_body_in_worker_queue = false;
 
-void check_procedure_later(CheckerContext *c, ProcInfo *info) {
+gb_internal void check_procedure_later(CheckerContext *c, ProcInfo *info) {
 	GB_ASSERT(info != nullptr);
 	GB_ASSERT(info->decl != nullptr);
 
@@ -1994,7 +1993,7 @@ void check_procedure_later(CheckerContext *c, ProcInfo *info) {
 	mpmc_enqueue(queue, info);
 }
 
-void check_procedure_later(CheckerContext *c, AstFile *file, Token token, DeclInfo *decl, Type *type, Ast *body, u64 tags) {
+gb_internal void check_procedure_later(CheckerContext *c, AstFile *file, Token token, DeclInfo *decl, Type *type, Ast *body, u64 tags) {
 	ProcInfo *info = gb_alloc_item(permanent_allocator(), ProcInfo);
 	info->file  = file;
 	info->token = token;
@@ -2006,7 +2005,7 @@ void check_procedure_later(CheckerContext *c, AstFile *file, Token token, DeclIn
 }
 
 
-void add_min_dep_type_info(Checker *c, Type *t) {
+gb_internal void add_min_dep_type_info(Checker *c, Type *t) {
 	if (t == nullptr) {
 		return;
 	}
@@ -2201,7 +2200,7 @@ void add_min_dep_type_info(Checker *c, Type *t) {
 }
 
 
-void add_dependency_to_set(Checker *c, Entity *entity) {
+gb_internal void add_dependency_to_set(Checker *c, Entity *entity) {
 	if (entity == nullptr) {
 		return;
 	}
@@ -2254,7 +2253,7 @@ void add_dependency_to_set(Checker *c, Entity *entity) {
 	}
 }
 
-void force_add_dependency_entity(Checker *c, Scope *scope, String const &name) {
+gb_internal void force_add_dependency_entity(Checker *c, Scope *scope, String const &name) {
 	Entity *e = scope_lookup(scope, name);
 	if (e == nullptr) {
 		return;
@@ -2266,7 +2265,7 @@ void force_add_dependency_entity(Checker *c, Scope *scope, String const &name) {
 
 
 
-void generate_minimum_dependency_set(Checker *c, Entity *start) {
+gb_internal void generate_minimum_dependency_set(Checker *c, Entity *start) {
 	isize entity_count = c->info.entities.count;
 	isize min_dep_set_cap = next_pow2_isize(entity_count*4); // empirically determined factor
 
@@ -2479,7 +2478,7 @@ void generate_minimum_dependency_set(Checker *c, Entity *start) {
 #undef FORCE_ADD_RUNTIME_ENTITIES
 }
 
-bool is_entity_a_dependency(Entity *e) {
+gb_internal bool is_entity_a_dependency(Entity *e) {
 	if (e == nullptr) return false;
 	switch (e->kind) {
 	case Entity_Procedure:
@@ -2493,7 +2492,7 @@ bool is_entity_a_dependency(Entity *e) {
 	return false;
 }
 
-Array<EntityGraphNode *> generate_entity_dependency_graph(CheckerInfo *info, gbAllocator allocator) {
+gb_internal Array<EntityGraphNode *> generate_entity_dependency_graph(CheckerInfo *info, gbAllocator allocator) {
 	PtrMap<Entity *, EntityGraphNode *> M = {};
 	map_init(&M, allocator, info->entities.count);
 	defer (map_destroy(&M));
@@ -2612,10 +2611,10 @@ Array<EntityGraphNode *> generate_entity_dependency_graph(CheckerInfo *info, gbA
 }
 
 
-void check_single_global_entity(Checker *c, Entity *e, DeclInfo *d);
+gb_internal void check_single_global_entity(Checker *c, Entity *e, DeclInfo *d);
 
 
-Entity *find_core_entity(Checker *c, String name) {
+gb_internal Entity *find_core_entity(Checker *c, String name) {
 	Entity *e = scope_lookup_current(c->info.runtime_package->scope, name);
 	if (e == nullptr) {
 		compiler_error("Could not find type declaration for '%.*s'\n"
@@ -2625,7 +2624,7 @@ Entity *find_core_entity(Checker *c, String name) {
 	return e;
 }
 
-Type *find_core_type(Checker *c, String name) {
+gb_internal Type *find_core_type(Checker *c, String name) {
 	Entity *e = scope_lookup_current(c->info.runtime_package->scope, name);
 	if (e == nullptr) {
 		compiler_error("Could not find type declaration for '%.*s'\n"
@@ -2640,7 +2639,7 @@ Type *find_core_type(Checker *c, String name) {
 }
 
 
-Entity *find_entity_in_pkg(CheckerInfo *info, String const &pkg, String const &name) {
+gb_internal Entity *find_entity_in_pkg(CheckerInfo *info, String const &pkg, String const &name) {
 	AstPackage *package = get_core_package(info, pkg);
 	Entity *e = scope_lookup_current(package->scope, name);
 	if (e == nullptr) {
@@ -2650,7 +2649,7 @@ Entity *find_entity_in_pkg(CheckerInfo *info, String const &pkg, String const &n
 	return e;
 }
 
-Type *find_type_in_pkg(CheckerInfo *info, String const &pkg, String const &name) {
+gb_internal Type *find_type_in_pkg(CheckerInfo *info, String const &pkg, String const &name) {
 	AstPackage *package = get_core_package(info, pkg);
 	Entity *e = scope_lookup_current(package->scope, name);
 	if (e == nullptr) {
@@ -2661,58 +2660,58 @@ Type *find_type_in_pkg(CheckerInfo *info, String const &pkg, String const &name)
 	return e->type;
 }
 
-CheckerTypePath *new_checker_type_path() {
+gb_internal CheckerTypePath *new_checker_type_path() {
 	gbAllocator a = heap_allocator();
 	auto *tp = gb_alloc_item(a, CheckerTypePath);
 	array_init(tp, a, 0, 16);
 	return tp;
 }
 
-void destroy_checker_type_path(CheckerTypePath *tp) {
+gb_internal void destroy_checker_type_path(CheckerTypePath *tp) {
 	array_free(tp);
 	gb_free(heap_allocator(), tp);
 }
 
 
-void check_type_path_push(CheckerContext *c, Entity *e) {
+gb_internal void check_type_path_push(CheckerContext *c, Entity *e) {
 	GB_ASSERT(c->type_path != nullptr);
 	GB_ASSERT(e != nullptr);
 	array_add(c->type_path, e);
 }
-Entity *check_type_path_pop(CheckerContext *c) {
+gb_internal Entity *check_type_path_pop(CheckerContext *c) {
 	GB_ASSERT(c->type_path != nullptr);
 	return array_pop(c->type_path);
 }
 
 
-CheckerPolyPath *new_checker_poly_path(void) {
+gb_internal CheckerPolyPath *new_checker_poly_path(void) {
 	gbAllocator a = heap_allocator();
 	auto *pp = gb_alloc_item(a, CheckerPolyPath);
 	array_init(pp, a, 0, 16);
 	return pp;
 }
 
-void destroy_checker_poly_path(CheckerPolyPath *pp) {
+gb_internal void destroy_checker_poly_path(CheckerPolyPath *pp) {
 	array_free(pp);
 	gb_free(heap_allocator(), pp);
 }
 
 
-void check_poly_path_push(CheckerContext *c, Type *t) {
+gb_internal void check_poly_path_push(CheckerContext *c, Type *t) {
 	GB_ASSERT(c->poly_path != nullptr);
 	GB_ASSERT(t != nullptr);
 	GB_ASSERT(is_type_polymorphic(t));
 	array_add(c->poly_path, t);
 }
 
-Type *check_poly_path_pop(CheckerContext *c) {
+gb_internal Type *check_poly_path_pop(CheckerContext *c) {
 	GB_ASSERT(c->poly_path != nullptr);
 	return array_pop(c->poly_path);
 }
 
 
 
-Array<Entity *> proc_group_entities(CheckerContext *c, Operand o) {
+gb_internal Array<Entity *> proc_group_entities(CheckerContext *c, Operand o) {
 	Array<Entity *> procs = {};
 	if (o.mode == Addressing_ProcGroup) {
 		GB_ASSERT(o.proc_group != nullptr);
@@ -2724,7 +2723,7 @@ Array<Entity *> proc_group_entities(CheckerContext *c, Operand o) {
 	return procs;
 }
 
-Array<Entity *> proc_group_entities_cloned(CheckerContext *c, Operand o) {
+gb_internal Array<Entity *> proc_group_entities_cloned(CheckerContext *c, Operand o) {
 	auto entities = proc_group_entities(c, o);
 	if (entities.count == 0) {
 		return {};
@@ -2735,7 +2734,7 @@ Array<Entity *> proc_group_entities_cloned(CheckerContext *c, Operand o) {
 
 
 
-void init_core_type_info(Checker *c) {
+gb_internal void init_core_type_info(Checker *c) {
 	if (t_type_info != nullptr) {
 		return;
 	}
@@ -2816,7 +2815,7 @@ void init_core_type_info(Checker *c) {
 	t_type_info_soa_pointer_ptr      = alloc_type_pointer(t_type_info_soa_pointer);
 }
 
-void init_mem_allocator(Checker *c) {
+gb_internal void init_mem_allocator(Checker *c) {
 	if (t_allocator != nullptr) {
 		return;
 	}
@@ -2825,7 +2824,7 @@ void init_mem_allocator(Checker *c) {
 	t_allocator_error = find_core_type(c, str_lit("Allocator_Error"));
 }
 
-void init_core_context(Checker *c) {
+gb_internal void init_core_context(Checker *c) {
 	if (t_context != nullptr) {
 		return;
 	}
@@ -2833,7 +2832,7 @@ void init_core_context(Checker *c) {
 	t_context_ptr = alloc_type_pointer(t_context);
 }
 
-void init_core_source_code_location(Checker *c) {
+gb_internal void init_core_source_code_location(Checker *c) {
 	if (t_source_code_location != nullptr) {
 		return;
 	}
@@ -2841,7 +2840,7 @@ void init_core_source_code_location(Checker *c) {
 	t_source_code_location_ptr = alloc_type_pointer(t_source_code_location);
 }
 
-void init_core_map_type(Checker *c) {
+gb_internal void init_core_map_type(Checker *c) {
 	if (t_map_info != nullptr) {
 		return;
 	}
@@ -2855,7 +2854,7 @@ void init_core_map_type(Checker *c) {
 	t_raw_map_ptr       = alloc_type_pointer(t_raw_map);
 }
 
-void init_preload(Checker *c) {
+gb_internal void init_preload(Checker *c) {
 	init_core_type_info(c);
 	init_mem_allocator(c);
 	init_core_context(c);
@@ -2863,7 +2862,7 @@ void init_preload(Checker *c) {
 	init_core_map_type(c);
 }
 
-ExactValue check_decl_attribute_value(CheckerContext *c, Ast *value) {
+gb_internal ExactValue check_decl_attribute_value(CheckerContext *c, Ast *value) {
 	ExactValue ev = {};
 	if (value != nullptr) {
 		Operand op = {};
@@ -2879,7 +2878,7 @@ ExactValue check_decl_attribute_value(CheckerContext *c, Ast *value) {
 	return ev;
 }
 
-Type *check_decl_attribute_type(CheckerContext *c, Ast *value) {
+gb_internal Type *check_decl_attribute_type(CheckerContext *c, Ast *value) {
 	if (value != nullptr) {
 		return check_type(c, value);
 	}
@@ -2890,7 +2889,7 @@ Type *check_decl_attribute_type(CheckerContext *c, Ast *value) {
 #define ATTRIBUTE_USER_TAG_NAME "tag"
 
 
-DECL_ATTRIBUTE_PROC(foreign_block_decl_attribute) {
+gb_internal DECL_ATTRIBUTE_PROC(foreign_block_decl_attribute) {
 	ExactValue ev = check_decl_attribute_value(c, value);
 
 	if (name == ATTRIBUTE_USER_TAG_NAME) {
@@ -2945,7 +2944,7 @@ DECL_ATTRIBUTE_PROC(foreign_block_decl_attribute) {
 	return false;
 }
 
-DECL_ATTRIBUTE_PROC(proc_decl_attribute) {
+gb_internal DECL_ATTRIBUTE_PROC(proc_decl_attribute) {
 	if (name == ATTRIBUTE_USER_TAG_NAME) {
 		ExactValue ev = check_decl_attribute_value(c, value);
 		if (ev.kind != ExactValue_String) {
@@ -3242,7 +3241,7 @@ DECL_ATTRIBUTE_PROC(proc_decl_attribute) {
 	return false;
 }
 
-DECL_ATTRIBUTE_PROC(var_decl_attribute) {
+gb_internal DECL_ATTRIBUTE_PROC(var_decl_attribute) {
 	if (name == ATTRIBUTE_USER_TAG_NAME) {
 		ExactValue ev = check_decl_attribute_value(c, value);
 		if (ev.kind != ExactValue_String) {
@@ -3367,7 +3366,7 @@ DECL_ATTRIBUTE_PROC(var_decl_attribute) {
 	return false;
 }
 
-DECL_ATTRIBUTE_PROC(const_decl_attribute) {
+gb_internal DECL_ATTRIBUTE_PROC(const_decl_attribute) {
 	if (name == ATTRIBUTE_USER_TAG_NAME) {
 		ExactValue ev = check_decl_attribute_value(c, value);
 		if (ev.kind != ExactValue_String) {
@@ -3381,7 +3380,7 @@ DECL_ATTRIBUTE_PROC(const_decl_attribute) {
 	return false;
 }
 
-DECL_ATTRIBUTE_PROC(type_decl_attribute) {
+gb_internal DECL_ATTRIBUTE_PROC(type_decl_attribute) {
 	if (name == ATTRIBUTE_USER_TAG_NAME) {
 		ExactValue ev = check_decl_attribute_value(c, value);
 		if (ev.kind != ExactValue_String) {
@@ -3412,7 +3411,7 @@ DECL_ATTRIBUTE_PROC(type_decl_attribute) {
 
 
 
-void check_decl_attributes(CheckerContext *c, Array<Ast *> const &attributes, DeclAttributeProc *proc, AttributeContext *ac) {
+gb_internal void check_decl_attributes(CheckerContext *c, Array<Ast *> const &attributes, DeclAttributeProc *proc, AttributeContext *ac) {
 	if (attributes.count == 0) return;
 
 	String original_link_prefix = {};
@@ -3480,7 +3479,7 @@ void check_decl_attributes(CheckerContext *c, Array<Ast *> const &attributes, De
 }
 
 
-isize get_total_value_count(Slice<Ast *> const &values) {
+gb_internal isize get_total_value_count(Slice<Ast *> const &values) {
 	isize count = 0;
 	for_array(i, values) {
 		Type *t = type_of_expr(values[i]);
@@ -3498,7 +3497,7 @@ isize get_total_value_count(Slice<Ast *> const &values) {
 	return count;
 }
 
-bool check_arity_match(CheckerContext *c, AstValueDecl *vd, bool is_global) {
+gb_internal bool check_arity_match(CheckerContext *c, AstValueDecl *vd, bool is_global) {
 	isize lhs = vd->names.count;
 	isize rhs = 0;
 	if (is_global) {
@@ -3541,7 +3540,7 @@ bool check_arity_match(CheckerContext *c, AstValueDecl *vd, bool is_global) {
 	return true;
 }
 
-void check_collect_entities_from_when_stmt(CheckerContext *c, AstWhenStmt *ws) {
+gb_internal void check_collect_entities_from_when_stmt(CheckerContext *c, AstWhenStmt *ws) {
 	Operand operand = {Addressing_Invalid};
 	if (!ws->is_cond_determined) {
 		check_expr(c, &operand, ws->cond);
@@ -3577,7 +3576,7 @@ void check_collect_entities_from_when_stmt(CheckerContext *c, AstWhenStmt *ws) {
 	}
 }
 
-void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array<Ast *> *attributes) {
+gb_internal void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array<Ast *> *attributes) {
 	switch (e->kind) {
 	case Entity_ProcGroup:
 	case Entity_Procedure:
@@ -3640,7 +3639,7 @@ void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array<Ast *> *attr
 	}
 }
 
-void check_collect_value_decl(CheckerContext *c, Ast *decl) {
+gb_internal void check_collect_value_decl(CheckerContext *c, Ast *decl) {
 	if (decl->state_flags & StateFlag_BeenHandled) return;
 	decl->state_flags |= StateFlag_BeenHandled;
 
@@ -3891,7 +3890,7 @@ void check_collect_value_decl(CheckerContext *c, Ast *decl) {
 	}
 }
 
-void check_add_foreign_block_decl(CheckerContext *ctx, Ast *decl) {
+gb_internal void check_add_foreign_block_decl(CheckerContext *ctx, Ast *decl) {
 	if (decl->state_flags & StateFlag_BeenHandled) return;
 	decl->state_flags |= StateFlag_BeenHandled;
 
@@ -3912,7 +3911,7 @@ void check_add_foreign_block_decl(CheckerContext *ctx, Ast *decl) {
 	check_collect_entities(&c, block->stmts);
 }
 
-bool correct_single_type_alias(CheckerContext *c, Entity *e) {
+gb_internal bool correct_single_type_alias(CheckerContext *c, Entity *e) {
 	if (e->kind == Entity_Constant) {
 		DeclInfo *d = e->decl_info;
 		if (d != nullptr && d->init_expr != nullptr) {
@@ -3927,7 +3926,7 @@ bool correct_single_type_alias(CheckerContext *c, Entity *e) {
 	return false;
 }
 
-bool correct_type_alias_in_scope_backwards(CheckerContext *c, Scope *s) {
+gb_internal bool correct_type_alias_in_scope_backwards(CheckerContext *c, Scope *s) {
 	isize n = s->elements.entries.count;
 	bool correction = false;
 	for (isize i = n-1; i >= 0; i--) {
@@ -3935,7 +3934,7 @@ bool correct_type_alias_in_scope_backwards(CheckerContext *c, Scope *s) {
 	}
 	return correction;
 }
-bool correct_type_alias_in_scope_forwards(CheckerContext *c, Scope *s) {
+gb_internal bool correct_type_alias_in_scope_forwards(CheckerContext *c, Scope *s) {
 	isize n = s->elements.entries.count;
 	bool correction = false;
 	for (isize i = 0; i < n; i++) {
@@ -3945,7 +3944,7 @@ bool correct_type_alias_in_scope_forwards(CheckerContext *c, Scope *s) {
 }
 
 
-void correct_type_aliases_in_scope(CheckerContext *c, Scope *s) {
+gb_internal void correct_type_aliases_in_scope(CheckerContext *c, Scope *s) {
 	// NOTE(bill, 2022-02-04): This is used to solve the problem caused by type aliases
 	// of type aliases being "confused" as constants
 	//
@@ -3966,7 +3965,7 @@ void correct_type_aliases_in_scope(CheckerContext *c, Scope *s) {
 
 
 // NOTE(bill): If file_scopes == nullptr, this will act like a local scope
-void check_collect_entities(CheckerContext *c, Slice<Ast *> const &nodes) {
+gb_internal void check_collect_entities(CheckerContext *c, Slice<Ast *> const &nodes) {
 	AstFile *curr_file = nullptr;
 	if ((c->scope->flags&ScopeFlag_File) != 0) {
 		curr_file = c->scope->file;
@@ -4050,13 +4049,13 @@ void check_collect_entities(CheckerContext *c, Slice<Ast *> const &nodes) {
 	}
 }
 
-CheckerContext *create_checker_context(Checker *c) {
+gb_internal CheckerContext *create_checker_context(Checker *c) {
 	CheckerContext *ctx = gb_alloc_item(permanent_allocator(), CheckerContext);
 	*ctx = make_checker_context(c);
 	return ctx;
 }
 
-void check_single_global_entity(Checker *c, Entity *e, DeclInfo *d) {
+gb_internal void check_single_global_entity(Checker *c, Entity *e, DeclInfo *d) {
 	GB_ASSERT(e != nullptr);
 	GB_ASSERT(d != nullptr);
 
@@ -4089,7 +4088,7 @@ void check_single_global_entity(Checker *c, Entity *e, DeclInfo *d) {
 	check_entity_decl(ctx, e, d, nullptr);
 }
 
-void check_all_global_entities(Checker *c) {
+gb_internal void check_all_global_entities(Checker *c) {
 	// NOTE(bill): This must be single threaded
 	// Don't bother trying
 	for_array(i, c->info.entities) {
@@ -4107,7 +4106,7 @@ void check_all_global_entities(Checker *c) {
 }
 
 
-bool is_string_an_identifier(String s) {
+gb_internal bool is_string_an_identifier(String s) {
 	isize offset = 0;
 	if (s.len < 1) {
 		return false;
@@ -4131,7 +4130,7 @@ bool is_string_an_identifier(String s) {
 	return offset == s.len;
 }
 
-String path_to_entity_name(String name, String fullpath, bool strip_extension=true) {
+gb_internal String path_to_entity_name(String name, String fullpath, bool strip_extension=true) {
 	if (name.len != 0) {
 		return name;
 	}
@@ -4177,7 +4176,7 @@ String path_to_entity_name(String name, String fullpath, bool strip_extension=tr
 
 #if 1
 
-void add_import_dependency_node(Checker *c, Ast *decl, PtrMap<AstPackage *, ImportGraphNode *> *M) {
+gb_internal void add_import_dependency_node(Checker *c, Ast *decl, PtrMap<AstPackage *, ImportGraphNode *> *M) {
 	AstPackage *parent_pkg = decl->file()->pkg;
 
 	switch (decl->kind) {
@@ -4242,7 +4241,7 @@ void add_import_dependency_node(Checker *c, Ast *decl, PtrMap<AstPackage *, Impo
 	}
 }
 
-Array<ImportGraphNode *> generate_import_dependency_graph(Checker *c) {
+gb_internal Array<ImportGraphNode *> generate_import_dependency_graph(Checker *c) {
 	PtrMap<AstPackage *, ImportGraphNode *> M = {};
 	map_init(&M, heap_allocator(), 2*c->parser->packages.count);
 	defer (map_destroy(&M));
@@ -4285,7 +4284,7 @@ struct ImportPathItem {
 	Ast *   decl;
 };
 
-Array<ImportPathItem> find_import_path(Checker *c, AstPackage *start, AstPackage *end, PtrSet<AstPackage *> *visited) {
+gb_internal Array<ImportPathItem> find_import_path(Checker *c, AstPackage *start, AstPackage *end, PtrSet<AstPackage *> *visited) {
 	Array<ImportPathItem> empty_path = {};
 
 	if (ptr_set_update(visited, start)) {
@@ -4335,7 +4334,7 @@ Array<ImportPathItem> find_import_path(Checker *c, AstPackage *start, AstPackage
 }
 #endif
 
-String get_invalid_import_name(String input) {
+gb_internal String get_invalid_import_name(String input) {
 	isize slash = 0;
 	for (isize i = input.len-1; i >= 0; i--) {
 		if (input[i] == '/' || input[i] == '\\') {
@@ -4347,7 +4346,7 @@ String get_invalid_import_name(String input) {
 	return input;
 }
 
-void check_add_import_decl(CheckerContext *ctx, Ast *decl) {
+gb_internal void check_add_import_decl(CheckerContext *ctx, Ast *decl) {
 	if (decl->state_flags & StateFlag_BeenHandled) return;
 	decl->state_flags |= StateFlag_BeenHandled;
 
@@ -4422,7 +4421,7 @@ void check_add_import_decl(CheckerContext *ctx, Ast *decl) {
 	scope->flags |= ScopeFlag_HasBeenImported;
 }
 
-DECL_ATTRIBUTE_PROC(foreign_import_decl_attribute) {
+gb_internal DECL_ATTRIBUTE_PROC(foreign_import_decl_attribute) {
 	if (name == ATTRIBUTE_USER_TAG_NAME) {
 		ExactValue ev = check_decl_attribute_value(c, value);
 		if (ev.kind != ExactValue_String) {
@@ -4449,7 +4448,7 @@ DECL_ATTRIBUTE_PROC(foreign_import_decl_attribute) {
 	return false;
 }
 
-void check_add_foreign_import_decl(CheckerContext *ctx, Ast *decl) {
+gb_internal void check_add_foreign_import_decl(CheckerContext *ctx, Ast *decl) {
 	if (decl->state_flags & StateFlag_BeenHandled) return;
 	decl->state_flags |= StateFlag_BeenHandled;
 
@@ -4515,10 +4514,10 @@ void check_add_foreign_import_decl(CheckerContext *ctx, Ast *decl) {
 }
 
 // Returns true if a new package is present
-bool collect_file_decls(CheckerContext *ctx, Slice<Ast *> const &decls);
-bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstWhenStmt *ws);
+gb_internal bool collect_file_decls(CheckerContext *ctx, Slice<Ast *> const &decls);
+gb_internal bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstWhenStmt *ws);
 
-bool collect_when_stmt_from_file(CheckerContext *ctx, AstWhenStmt *ws) {
+gb_internal bool collect_when_stmt_from_file(CheckerContext *ctx, AstWhenStmt *ws) {
 	Operand operand = {Addressing_Invalid};
 	if (!ws->is_cond_determined) {
 		check_expr(ctx, &operand, ws->cond);
@@ -4557,7 +4556,7 @@ bool collect_when_stmt_from_file(CheckerContext *ctx, AstWhenStmt *ws) {
 	return false;
 }
 
-bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstWhenStmt *ws) {
+gb_internal bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstWhenStmt *ws) {
 	Operand operand = {Addressing_Invalid};
 	if (!ws->is_cond_determined) {
 		check_expr(ctx, &operand, ws->cond);
@@ -4594,7 +4593,7 @@ bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstWhenStmt *ws) {
 }
 
 
-bool collect_file_decl(CheckerContext *ctx, Ast *decl) {
+gb_internal bool collect_file_decl(CheckerContext *ctx, Ast *decl) {
 	GB_ASSERT(ctx->scope->flags&ScopeFlag_File);
 
 	AstFile *curr_file = ctx->scope->file;
@@ -4658,7 +4657,7 @@ bool collect_file_decl(CheckerContext *ctx, Ast *decl) {
 	return false;
 }
 
-bool collect_file_decls(CheckerContext *ctx, Slice<Ast *> const &decls) {
+gb_internal bool collect_file_decls(CheckerContext *ctx, Slice<Ast *> const &decls) {
 	GB_ASSERT(ctx->scope->flags&ScopeFlag_File);
 
 	for_array(i, decls) {
@@ -4671,7 +4670,7 @@ bool collect_file_decls(CheckerContext *ctx, Slice<Ast *> const &decls) {
 	return false;
 }
 
-GB_COMPARE_PROC(sort_file_by_name) {
+gb_internal GB_COMPARE_PROC(sort_file_by_name) {
 	AstFile const *x = *cast(AstFile const **)a;
 	AstFile const *y = *cast(AstFile const **)b;
 	String x_name = filename_from_path(x->fullpath);
@@ -4679,7 +4678,7 @@ GB_COMPARE_PROC(sort_file_by_name) {
 	return string_compare(x_name, y_name);
 }
 
-void check_create_file_scopes(Checker *c) {
+gb_internal void check_create_file_scopes(Checker *c) {
 	for_array(i, c->parser->packages) {
 		AstPackage *pkg = c->parser->packages[i];
 		isize total_pkg_decl_count = 0;
@@ -4705,7 +4704,7 @@ struct ThreadProcCheckerSection {
 };
 
 
-void check_with_workers(Checker *c, WorkerTaskProc *proc, isize total_count) {
+gb_internal void check_with_workers(Checker *c, WorkerTaskProc *proc, isize total_count) {
 	isize thread_count = gb_max(build_context.thread_count, 1);
 	isize worker_count = thread_count-1; // NOTE(bill): The main thread will also be used for work
 	if (!build_context.threaded_checker) {
@@ -4744,7 +4743,7 @@ void check_with_workers(Checker *c, WorkerTaskProc *proc, isize total_count) {
 }
 
 
-WORKER_TASK_PROC(thread_proc_collect_entities) {
+gb_internal WORKER_TASK_PROC(thread_proc_collect_entities) {
 	auto *cs = cast(ThreadProcCheckerSection *)data;
 	Checker *c = cs->checker;
 	CheckerContext collect_entity_ctx = make_checker_context(c);
@@ -4775,11 +4774,11 @@ WORKER_TASK_PROC(thread_proc_collect_entities) {
 }
 
 
-void check_collect_entities_all(Checker *c) {
+gb_internal void check_collect_entities_all(Checker *c) {
 	check_with_workers(c, thread_proc_collect_entities, c->info.files.entries.count);
 }
 
-void check_export_entities_in_pkg(CheckerContext *ctx, AstPackage *pkg, UntypedExprInfoMap *untyped) {
+gb_internal void check_export_entities_in_pkg(CheckerContext *ctx, AstPackage *pkg, UntypedExprInfoMap *untyped) {
 	if (pkg->files.count != 0) {
 		AstPackageExportedEntity item = {};
 		while (mpmc_dequeue(&pkg->exported_entity_queue, &item)) {
@@ -4793,7 +4792,7 @@ void check_export_entities_in_pkg(CheckerContext *ctx, AstPackage *pkg, UntypedE
 	}
 }
 
-WORKER_TASK_PROC(thread_proc_check_export_entities) {
+gb_internal WORKER_TASK_PROC(thread_proc_check_export_entities) {
 	auto cs = cast(ThreadProcCheckerSection *)data;
 	Checker *c = cs->checker;
 
@@ -4815,11 +4814,11 @@ WORKER_TASK_PROC(thread_proc_check_export_entities) {
 	return 0;
 }
 
-void check_export_entities(Checker *c) {
+gb_internal void check_export_entities(Checker *c) {
 	check_with_workers(c, thread_proc_check_export_entities, c->info.packages.entries.count);
 }
 
-void check_import_entities(Checker *c) {
+gb_internal void check_import_entities(Checker *c) {
 	Array<ImportGraphNode *> dep_graph = generate_import_dependency_graph(c);
 	defer ({
 		for_array(i, dep_graph) {
@@ -4961,9 +4960,9 @@ void check_import_entities(Checker *c) {
 }
 
 
-Array<Entity *> find_entity_path(Entity *start, Entity *end, PtrSet<Entity *> *visited = nullptr);
+gb_internal Array<Entity *> find_entity_path(Entity *start, Entity *end, PtrSet<Entity *> *visited = nullptr);
 
-bool find_entity_path_tuple(Type *tuple, Entity *end, PtrSet<Entity *> *visited, Array<Entity *> *path_) {
+gb_internal bool find_entity_path_tuple(Type *tuple, Entity *end, PtrSet<Entity *> *visited, Array<Entity *> *path_) {
 	GB_ASSERT(path_ != nullptr);
 	if (tuple == nullptr) {
 		return false;
@@ -4995,7 +4994,7 @@ bool find_entity_path_tuple(Type *tuple, Entity *end, PtrSet<Entity *> *visited,
 	return false;
 }
 
-Array<Entity *> find_entity_path(Entity *start, Entity *end, PtrSet<Entity *> *visited) {
+gb_internal Array<Entity *> find_entity_path(Entity *start, Entity *end, PtrSet<Entity *> *visited) {
 	PtrSet<Entity *> visited_ = {};
 	bool made_visited = false;
 	if (visited == nullptr) {
@@ -5047,7 +5046,7 @@ Array<Entity *> find_entity_path(Entity *start, Entity *end, PtrSet<Entity *> *v
 }
 
 
-void calculate_global_init_order(Checker *c) {
+gb_internal void calculate_global_init_order(Checker *c) {
 	CheckerInfo *info = &c->info;
 
 	TIME_SECTION("calculate_global_init_order: generate entity dependency graph");
@@ -5122,7 +5121,7 @@ void calculate_global_init_order(Checker *c) {
 }
 
 
-bool check_proc_info(Checker *c, ProcInfo *pi, UntypedExprInfoMap *untyped, ProcBodyQueue *procs_to_check_queue) {
+gb_internal bool check_proc_info(Checker *c, ProcInfo *pi, UntypedExprInfoMap *untyped, ProcBodyQueue *procs_to_check_queue) {
 	if (pi == nullptr) {
 		return false;
 	}
@@ -5201,9 +5200,9 @@ bool check_proc_info(Checker *c, ProcInfo *pi, UntypedExprInfoMap *untyped, Proc
 
 GB_STATIC_ASSERT(sizeof(isize) == sizeof(void *));
 
-bool consume_proc_info_queue(Checker *c, ProcInfo *pi, ProcBodyQueue *q, UntypedExprInfoMap *untyped);
+gb_internal bool consume_proc_info_queue(Checker *c, ProcInfo *pi, ProcBodyQueue *q, UntypedExprInfoMap *untyped);
 
-void check_unchecked_bodies(Checker *c) {
+gb_internal void check_unchecked_bodies(Checker *c) {
 	// NOTE(2021-02-26, bill): Sanity checker
 	// This is a partial hack to make sure all procedure bodies have been checked
 	// even ones which should not exist, due to the multithreaded nature of the parser
@@ -5255,7 +5254,7 @@ void check_unchecked_bodies(Checker *c) {
 
 }
 
-void check_test_procedures(Checker *c) {
+gb_internal void check_test_procedures(Checker *c) {
 	if (build_context.test_names.entries.count == 0) {
 		return;
 	}
@@ -5290,7 +5289,7 @@ void check_test_procedures(Checker *c) {
 
 gb_global std::atomic<isize> total_bodies_checked;
 
-bool consume_proc_info_queue(Checker *c, ProcInfo *pi, ProcBodyQueue *q, UntypedExprInfoMap *untyped) {
+gb_internal bool consume_proc_info_queue(Checker *c, ProcInfo *pi, ProcBodyQueue *q, UntypedExprInfoMap *untyped) {
 	GB_ASSERT(pi->decl != nullptr);
 	if (pi->decl->parent && pi->decl->parent->entity) {
 		Entity *parent = pi->decl->parent->entity;
@@ -5318,7 +5317,7 @@ struct ThreadProcBodyData {
 	ThreadProcBodyData *all_data;
 };
 
-WORKER_TASK_PROC(thread_proc_body) {
+gb_internal WORKER_TASK_PROC(thread_proc_body) {
 	ThreadProcBodyData *bd = cast(ThreadProcBodyData *)data;
 	Checker *c = bd->checker;
 	GB_ASSERT(c != nullptr);
@@ -5338,7 +5337,7 @@ WORKER_TASK_PROC(thread_proc_body) {
 	return 0;
 }
 
-void check_procedure_bodies(Checker *c) {
+gb_internal void check_procedure_bodies(Checker *c) {
 	GB_ASSERT(c != nullptr);
 
 	u32 thread_count = cast(u32)gb_max(build_context.thread_count, 1);
@@ -5414,7 +5413,7 @@ void check_procedure_bodies(Checker *c) {
 
 	global_procedure_body_in_worker_queue = false;
 }
-void add_untyped_expressions(CheckerInfo *cinfo, UntypedExprInfoMap *untyped) {
+gb_internal void add_untyped_expressions(CheckerInfo *cinfo, UntypedExprInfoMap *untyped) {
 	if (untyped == nullptr) {
 		return;
 	}
@@ -5428,7 +5427,7 @@ void add_untyped_expressions(CheckerInfo *cinfo, UntypedExprInfoMap *untyped) {
 	map_clear(untyped);
 }
 
-void check_deferred_procedures(Checker *c) {
+gb_internal void check_deferred_procedures(Checker *c) {
 	for (Entity *src = nullptr; mpmc_dequeue(&c->procs_with_deferred_to_check, &src); /**/) {
 		GB_ASSERT(src->kind == Entity_Procedure);
 
@@ -5581,7 +5580,7 @@ void check_deferred_procedures(Checker *c) {
 
 }
 
-void check_unique_package_names(Checker *c) {
+gb_internal void check_unique_package_names(Checker *c) {
 	StringMap<AstPackage *> pkgs = {}; // Key: package name
 	string_map_init(&pkgs, heap_allocator(), 2*c->info.packages.entries.count);
 	defer (string_map_destroy(&pkgs));
@@ -5614,7 +5613,7 @@ void check_unique_package_names(Checker *c) {
 	}
 }
 
-void check_add_entities_from_queues(Checker *c) {
+gb_internal void check_add_entities_from_queues(Checker *c) {
 	isize cap = c->info.entities.count + c->info.entity_queue.count.load(std::memory_order_relaxed);
 	array_reserve(&c->info.entities, cap);
 	for (Entity *e; mpmc_dequeue(&c->info.entity_queue, &e); /**/) {
@@ -5622,7 +5621,7 @@ void check_add_entities_from_queues(Checker *c) {
 	}
 }
 
-void check_add_definitions_from_queues(Checker *c) {
+gb_internal void check_add_definitions_from_queues(Checker *c) {
 	isize cap = c->info.definitions.count + c->info.definition_queue.count.load(std::memory_order_relaxed);
 	array_reserve(&c->info.definitions, cap);
 	for (Entity *e; mpmc_dequeue(&c->info.definition_queue, &e); /**/) {
@@ -5630,12 +5629,12 @@ void check_add_definitions_from_queues(Checker *c) {
 	}
 }
 
-void check_merge_queues_into_arrays(Checker *c) {
+gb_internal void check_merge_queues_into_arrays(Checker *c) {
 	check_add_entities_from_queues(c);
 	check_add_definitions_from_queues(c);
 }
 
-GB_COMPARE_PROC(init_procedures_cmp) {
+gb_internal GB_COMPARE_PROC(init_procedures_cmp) {
 	int cmp = 0;
 	Entity *x = *(Entity **)a;
 	Entity *y = *(Entity **)b;
@@ -5673,11 +5672,11 @@ GB_COMPARE_PROC(init_procedures_cmp) {
 }
 
 
-void check_sort_init_procedures(Checker *c) {
+gb_internal void check_sort_init_procedures(Checker *c) {
 	gb_sort_array(c->info.init_procedures.data, c->info.init_procedures.count, init_procedures_cmp);
 }
 
-void add_type_info_for_type_definitions(Checker *c) {
+gb_internal void add_type_info_for_type_definitions(Checker *c) {
 	for_array(i, c->info.definitions) {
 		Entity *e = c->info.definitions[i];
 		if (e->kind == Entity_TypeName && e->type != nullptr) {
@@ -5689,7 +5688,7 @@ void add_type_info_for_type_definitions(Checker *c) {
 	}
 }
 
-void check_parsed_files(Checker *c) {
+gb_internal void check_parsed_files(Checker *c) {
 	TIME_SECTION("map full filepaths to scope");
 	add_type_info_type(&c->builtin_ctx, t_invalid);