diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/check_decl.cpp | 171 | ||||
| -rw-r--r-- | src/check_expr.cpp | 305 | ||||
| -rw-r--r-- | src/check_stmt.cpp | 364 | ||||
| -rw-r--r-- | src/check_type.cpp | 382 | ||||
| -rw-r--r-- | src/checker.cpp | 310 | ||||
| -rw-r--r-- | src/checker.hpp | 38 | ||||
| -rw-r--r-- | src/ir.cpp | 14 |
7 files changed, 799 insertions, 785 deletions
diff --git a/src/check_decl.cpp b/src/check_decl.cpp index acfb3140d..42b578605 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -1,8 +1,8 @@ bool check_is_terminating(AstNode *node); -void check_stmt (Checker *c, AstNode *node, u32 flags); +void check_stmt (CheckerContext *ctx, AstNode *node, u32 flags); // NOTE(bill): 'content_name' is for debugging and error messages -Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String context_name) { +Type *check_init_variable(CheckerContext *ctx, Entity *e, Operand *operand, String context_name) { if (operand->mode == Addressing_Invalid || operand->type == t_invalid || e->type == t_invalid) { @@ -27,7 +27,7 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex if (e->type == nullptr) { error(operand->expr, "Cannot determine type from overloaded procedure '%.*s'", LIT(operand->proc_group->token.string)); } else { - check_assignment(c, operand, e->type, str_lit("variable assignment")); + check_assignment(ctx, operand, e->type, str_lit("variable assignment")); if (operand->mode != Addressing_Type) { return operand->type; } @@ -79,9 +79,9 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex e->type = t; } - e->parent_proc_decl = c->context.curr_proc_decl; + e->parent_proc_decl = ctx->curr_proc_decl; - check_assignment(c, operand, e->type, context_name); + check_assignment(ctx, operand, e->type, context_name); if (operand->mode == Addressing_Invalid) { return nullptr; } @@ -89,7 +89,7 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex return e->type; } -void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, Array<AstNode *> inits, String context_name) { +void check_init_variables(CheckerContext *ctx, Entity **lhs, isize lhs_count, Array<AstNode *> inits, String context_name) { if ((lhs == nullptr || lhs_count == 0) && inits.count == 0) { return; } @@ -97,9 +97,9 @@ void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, Array<AstNo // NOTE(bill): If there is a bad syntax error, rhs > lhs which would mean there would need to be // an extra allocation - auto operands = array_make<Operand>(c->allocator, 0, 2*lhs_count); + auto operands = array_make<Operand>(ctx->allocator, 0, 2*lhs_count); defer (array_free(&operands)); - check_unpack_arguments(c, lhs, lhs_count, &operands, inits, true); + check_unpack_arguments(ctx, lhs, lhs_count, &operands, inits, true); isize rhs_count = operands.count; for_array(i, operands) { @@ -111,9 +111,9 @@ void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, Array<AstNo isize max = gb_min(lhs_count, rhs_count); for (isize i = 0; i < max; i++) { Entity *e = lhs[i]; - DeclInfo *d = decl_info_of_entity(&c->info, e); + DeclInfo *d = decl_info_of_entity(&ctx->checker->info, e); Operand *o = &operands[i]; - check_init_variable(c, e, o, context_name); + check_init_variable(ctx, e, o, context_name); if (d != nullptr) { d->init_expr = o->expr; } @@ -123,7 +123,7 @@ void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, Array<AstNo } } -void check_init_constant(Checker *c, Entity *e, Operand *operand) { +void check_init_constant(CheckerContext *ctx, Entity *e, Operand *operand) { if (operand->mode == Addressing_Invalid || operand->type == t_invalid || e->type == t_invalid) { @@ -157,12 +157,12 @@ void check_init_constant(Checker *c, Entity *e, Operand *operand) { e->type = operand->type; } - check_assignment(c, operand, e->type, str_lit("constant declaration")); + check_assignment(ctx, operand, e->type, str_lit("constant declaration")); if (operand->mode == Addressing_Invalid) { return; } - e->parent_proc_decl = c->context.curr_proc_decl; + e->parent_proc_decl = ctx->curr_proc_decl; e->Constant.value = operand->value; } @@ -217,10 +217,10 @@ AstNode *remove_type_alias_clutter(AstNode *node) { } } -void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def) { +void check_type_decl(CheckerContext *ctx, Entity *e, AstNode *type_expr, Type *def) { GB_ASSERT(e->type == nullptr); - DeclInfo *decl = decl_info_of_entity(&c->info, e); + DeclInfo *decl = decl_info_of_entity(&ctx->checker->info, e); if (decl != nullptr && decl->attributes.count > 0) { error(decl->attributes[0], "Attributes are not allowed on type declarations"); } @@ -238,9 +238,9 @@ void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def) { } e->type = named; - check_type_path_push(c, e); - Type *bt = check_type_expr(c, te, named); - check_type_path_pop(c); + check_type_path_push(ctx, e); + Type *bt = check_type_expr(ctx, te, named); + check_type_path_pop(ctx); named->Named.base = base_type(bt); if (!is_distinct) { @@ -260,7 +260,7 @@ void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def) { // } } -void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, Type *named_type) { +void check_const_decl(CheckerContext *ctx, Entity *e, AstNode *type_expr, AstNode *init, Type *named_type) { GB_ASSERT(e->type == nullptr); GB_ASSERT(e->kind == Entity_Constant); @@ -271,7 +271,7 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, e->flags |= EntityFlag_Visited; if (type_expr) { - Type *t = check_type(c, type_expr); + Type *t = check_type(ctx, type_expr); if (!is_type_constant_type(t)) { gbString str = type_to_string(t); error(type_expr, "Invalid constant type '%s'", str); @@ -287,11 +287,11 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, if (init != nullptr) { Entity *entity = nullptr; if (init->kind == AstNode_Ident) { - entity = check_ident(c, &operand, init, nullptr, e->type, true); + entity = check_ident(ctx, &operand, init, nullptr, e->type, true); } else if (init->kind == AstNode_SelectorExpr) { - entity = check_selector(c, &operand, init, e->type); + entity = check_selector(ctx, &operand, init, e->type); } else { - check_expr_or_type(c, &operand, init, e->type); + check_expr_or_type(ctx, &operand, init, e->type); } switch (operand.mode) { @@ -299,12 +299,12 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, e->kind = Entity_TypeName; e->type = nullptr; - DeclInfo *d = c->context.decl; + DeclInfo *d = ctx->decl; if (d->type_expr != nullptr) { error(e->token, "A type declaration cannot have an type parameter"); } d->type_expr = d->init_expr; - check_type_decl(c, e, d->type_expr, named_type); + check_type_decl(ctx, e, d->type_expr, named_type); return; } @@ -360,10 +360,10 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, } if (init != nullptr) { - check_expr_or_type(c, &operand, init, e->type); + check_expr_or_type(ctx, &operand, init, e->type); } - check_init_constant(c, e, &operand); + check_init_constant(ctx, e, &operand); if (operand.mode == Addressing_Invalid || base_type(operand.type) == t_invalid) { @@ -373,7 +373,7 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, } - DeclInfo *decl = decl_info_of_entity(&c->info, e); + DeclInfo *decl = decl_info_of_entity(&ctx->checker->info, e); if (decl != nullptr && decl->attributes.count > 0) { error(decl->attributes[0], "Attributes are not allowed on constant value declarations"); } @@ -433,7 +433,7 @@ bool are_signatures_similar_enough(Type *a_, Type *b_) { return true; } -void init_entity_foreign_library(Checker *c, Entity *e) { +void init_entity_foreign_library(CheckerContext *ctx, Entity *e) { AstNode *ident = nullptr; Entity **foreign_library = nullptr; @@ -456,7 +456,7 @@ void init_entity_foreign_library(Checker *c, Entity *e) { error(ident, "foreign library names must be an identifier"); } else { String name = ident->Ident.token.string; - Entity *found = scope_lookup_entity(c->context.scope, name); + Entity *found = scope_lookup_entity(ctx->scope, name); if (found == nullptr) { if (is_blank_ident(name)) { error(ident, "'_' cannot be used as a value type"); @@ -469,18 +469,18 @@ void init_entity_foreign_library(Checker *c, Entity *e) { // TODO(bill): Extra stuff to do with library names? *foreign_library = found; found->LibraryName.used = true; - add_entity_use(c, ident, found); + add_entity_use(ctx, ident, found); } } } -String handle_link_name(Checker *c, Token token, String link_name, String link_prefix) { +String handle_link_name(CheckerContext *ctx, Token token, String link_name, String link_prefix) { if (link_prefix.len > 0) { if (link_name.len > 0) { error(token, "'link_name' and 'link_prefix' cannot be used together"); } else { isize len = link_prefix.len + token.string.len; - u8 *name = gb_alloc_array(c->allocator, u8, len+1); + u8 *name = gb_alloc_array(ctx->allocator, u8, len+1); gb_memmove(name, &link_prefix[0], link_prefix.len); gb_memmove(name+link_prefix.len, &token.string[0], token.string.len); name[len] = 0; @@ -491,7 +491,7 @@ String handle_link_name(Checker *c, Token token, String link_name, String link_p return link_name; } -void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { +void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) { GB_ASSERT(e->type == nullptr); if (d->proc_lit->kind != AstNode_ProcLit) { // TOOD(bill): Better error message @@ -508,14 +508,13 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { e->type = proc_type; ast_node(pl, ProcLit, d->proc_lit); - check_open_scope(c, pl->type); - defer (check_close_scope(c)); + check_open_scope(ctx, pl->type); + defer (check_close_scope(ctx)); - auto prev_context = c->context; - c->context.allow_polymorphic_types = true; - check_procedure_type(c, proc_type, pl->type); - c->context = prev_context; + auto tmp_ctx = *ctx; + tmp_ctx.allow_polymorphic_types = true; + check_procedure_type(&tmp_ctx, proc_type, pl->type); TypeProc *pt = &proc_type->Proc; @@ -526,11 +525,11 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { AttributeContext ac = make_attribute_context(e->Procedure.link_prefix); if (d != nullptr) { - check_decl_attributes(c, d->attributes, proc_decl_attribute, &ac); + check_decl_attributes(ctx, d->attributes, proc_decl_attribute, &ac); } e->deprecated_message = ac.deprecated_message; - ac.link_name = handle_link_name(c, e->token, ac.link_name, ac.link_prefix); + ac.link_name = handle_link_name(ctx, e->token, ac.link_name, ac.link_prefix); if (e->pkg != nullptr && e->token.string == "main") { if (pt->param_count != 0 || @@ -545,10 +544,10 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { } pt->calling_convention = ProcCC_Contextless; if (e->pkg->kind == Package_Init) { - if (c->info.entry_point != nullptr) { + if (ctx->checker->info.entry_point != nullptr) { error(e->token, "Redeclaration of the entry pointer procedure 'main'"); } else { - c->info.entry_point = e; + ctx->checker->info.entry_point = e; } } } @@ -576,11 +575,11 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { error(pl->body, "A procedure with a '#c_vararg' field cannot have a body and must be foreign"); } - d->scope = c->context.scope; + d->scope = ctx->scope; GB_ASSERT(pl->body->kind == AstNode_BlockStmt); if (!pt->is_polymorphic) { - check_procedure_later(c, c->context.file, e->token, d, proc_type, pl->body, pl->tags); + check_procedure_later(ctx->checker, ctx->file, e->token, d, proc_type, pl->body, pl->tags); } } else if (!is_foreign) { if (e->Procedure.is_export) { @@ -608,9 +607,9 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { e->Procedure.is_foreign = true; e->Procedure.link_name = name; - init_entity_foreign_library(c, e); + init_entity_foreign_library(ctx, e); - auto *fp = &c->info.foreigns; + auto *fp = &ctx->checker->info.foreigns; HashKey key = hash_string(name); Entity **found = map_get(fp, key); if (found) { @@ -642,7 +641,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { name = e->Procedure.link_name; } if (e->Procedure.link_name.len > 0 || is_export) { - auto *fp = &c->info.foreigns; + auto *fp = &ctx->checker->info.foreigns; HashKey key = hash_string(name); Entity **found = map_get(fp, key); if (found) { @@ -662,7 +661,7 @@ 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, Array<AstNode *> init_expr_list) { +void check_var_decl(CheckerContext *ctx, Entity *e, Entity **entities, isize entity_count, AstNode *type_expr, Array<AstNode *> init_expr_list) { GB_ASSERT(e->type == nullptr); GB_ASSERT(e->kind == Entity_Variable); @@ -675,18 +674,18 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count AttributeContext ac = make_attribute_context(e->Variable.link_prefix); ac.init_expr_list_count = init_expr_list.count; - DeclInfo *decl = decl_info_of_entity(&c->info, e); + DeclInfo *decl = decl_info_of_entity(&ctx->checker->info, e); if (decl != nullptr) { - check_decl_attributes(c, decl->attributes, var_decl_attribute, &ac); + check_decl_attributes(ctx, decl->attributes, var_decl_attribute, &ac); } - ac.link_name = handle_link_name(c, e->token, ac.link_name, ac.link_prefix); + ac.link_name = handle_link_name(ctx, e->token, ac.link_name, ac.link_prefix); e->Variable.thread_local_model = ac.thread_local_model; String context_name = str_lit("variable declaration"); if (type_expr != nullptr) { - e->type = check_type(c, type_expr); + e->type = check_type(ctx, type_expr); } if (e->type != nullptr) { if (is_type_polymorphic(base_type(e->type))) { @@ -707,7 +706,7 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count if (init_expr_list.count > 0) { error(e->token, "A foreign variable declaration cannot have a default value"); } - init_entity_foreign_library(c, e); + init_entity_foreign_library(ctx, e); } if (ac.link_name.len > 0) { e->Variable.link_name = ac.link_name; @@ -718,7 +717,7 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count if (e->Variable.link_name.len > 0) { name = e->Variable.link_name; } - auto *fp = &c->info.foreigns; + auto *fp = &ctx->checker->info.foreigns; HashKey key = hash_string(name); Entity **found = map_get(fp, key); if (found) { @@ -750,17 +749,17 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count } } - check_init_variables(c, entities, entity_count, init_expr_list, context_name); + check_init_variables(ctx, entities, entity_count, init_expr_list, context_name); } -void check_proc_group_decl(Checker *c, Entity *pg_entity, DeclInfo *d) { +void check_proc_group_decl(CheckerContext *ctx, Entity *pg_entity, DeclInfo *d) { GB_ASSERT(pg_entity->kind == Entity_ProcGroup); auto *pge = &pg_entity->ProcGroup; String proc_group_name = pg_entity->token.string; ast_node(pg, ProcGroup, d->init_expr); - pge->entities = array_make<Entity*>(c->allocator, 0, pg->args.count); + pge->entities = array_make<Entity*>(ctx->allocator, 0, pg->args.count); // NOTE(bill): This must be set here to prevent cycles in checking if someone // places the entity within itself @@ -775,9 +774,9 @@ void check_proc_group_decl(Checker *c, Entity *pg_entity, DeclInfo *d) { Entity *e = nullptr; Operand o = {}; if (arg->kind == AstNode_Ident) { - e = check_ident(c, &o, arg, nullptr, nullptr, true); + e = check_ident(ctx, &o, arg, nullptr, nullptr, true); } else if (arg->kind == AstNode_SelectorExpr) { - e = check_selector(c, &o, arg, nullptr); + e = check_selector(ctx, &o, arg, nullptr); } if (e == nullptr) { error(arg, "Expected a valid entity name in procedure group, got %.*s", LIT(ast_node_strings[arg->kind])); @@ -865,7 +864,7 @@ void check_proc_group_decl(Checker *c, Entity *pg_entity, DeclInfo *d) { } -void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) { +void check_entity_decl(CheckerContext *ctx, Entity *e, DeclInfo *d, Type *named_type) { if (e->state == EntityState_Resolved) { return; } @@ -893,7 +892,7 @@ void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) { #endif if (d == nullptr) { - d = decl_info_of_entity(&c->info, e); + d = decl_info_of_entity(&ctx->checker->info, e); if (d == nullptr) { // TODO(bill): Err here? e->type = t_invalid; @@ -904,43 +903,41 @@ void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) { } } - CheckerContext prev = c->context; - c->context.scope = d->scope; - c->context.decl = d; - c->context.type_level = 0; + CheckerContext c = *ctx; + c.scope = d->scope; + c.decl = d; + c.type_level = 0; - e->parent_proc_decl = c->context.curr_proc_decl; + e->parent_proc_decl = c.curr_proc_decl; e->state = EntityState_InProgress; switch (e->kind) { case Entity_Variable: - check_var_decl(c, e, d->entities, d->entity_count, d->type_expr, d->init_expr_list); + check_var_decl(&c, e, d->entities, d->entity_count, d->type_expr, d->init_expr_list); break; case Entity_Constant: - check_const_decl(c, e, d->type_expr, d->init_expr, named_type); + check_const_decl(&c, e, d->type_expr, d->init_expr, named_type); break; case Entity_TypeName: { - check_type_decl(c, e, d->type_expr, named_type); + check_type_decl(&c, e, d->type_expr, named_type); break; } case Entity_Procedure: - check_proc_decl(c, e, d); + check_proc_decl(&c, e, d); break; case Entity_ProcGroup: - check_proc_group_decl(c, e, d); + check_proc_group_decl(&c, e, d); break; } e->state = EntityState_Resolved; - c->context = prev; - #undef TIME_SECTION } -void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNode *body) { +void check_proc_body(CheckerContext *ctx_, Token token, DeclInfo *decl, Type *type, AstNode *body) { if (body == nullptr) { return; } @@ -954,14 +951,14 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod proc_name = str_lit("(anonymous-procedure)"); } - CheckerContext old_context = c->context; - defer (c->context = old_context); + CheckerContext new_ctx = *ctx_; + CheckerContext *ctx = &new_ctx; - c->context.scope = decl->scope; - c->context.decl = decl; - c->context.proc_name = proc_name; - c->context.curr_proc_decl = decl; - c->context.curr_proc_sig = type; + ctx->scope = decl->scope; + ctx->decl = decl; + ctx->proc_name = proc_name; + ctx->curr_proc_decl = decl; + ctx->curr_proc_sig = type; GB_ASSERT(type->kind == Type_Proc); if (type->Proc.param_count > 0) { @@ -981,7 +978,7 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod if (t->kind == Type_Struct) { Scope *scope = t->Struct.scope; if (scope == nullptr) { - scope = scope_of_node(&c->info, t->Struct.node); + scope = scope_of_node(&ctx->checker->info, t->Struct.node); } GB_ASSERT(scope != nullptr); for_array(i, scope->elements.entries) { @@ -991,7 +988,7 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod uvar->Variable.is_immutable = is_immutable; if (is_value) uvar->flags |= EntityFlag_Value; - Entity *prev = scope_insert_entity(c->context.scope, uvar); + Entity *prev = scope_insert_entity(ctx->scope, uvar); if (prev != nullptr) { error(e->token, "Namespace collision while 'using' '%.*s' of: %.*s", LIT(name), LIT(prev->token.string)); break; @@ -1006,7 +1003,7 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod } ast_node(bs, BlockStmt, body); - check_stmt_list(c, bs->stmts, Stmt_CheckScopeDecls); + check_stmt_list(ctx, bs->stmts, Stmt_CheckScopeDecls); if (type->Proc.result_count > 0) { if (!check_is_terminating(body)) { if (token.kind == Token_Ident) { @@ -1017,7 +1014,7 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod } } - check_scope_usage(c, c->context.scope); + check_scope_usage(ctx->checker, ctx->scope); if (decl->parent != nullptr) { // NOTE(bill): Add the dependencies from the procedure literal (lambda) diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 78f682884..181de0654 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -45,41 +45,41 @@ int valid_index_and_score_cmp(void const *a, void const *b) { -#define CALL_ARGUMENT_CHECKER(name) CallArgumentError name(Checker *c, AstNode *call, Type *proc_type, Entity *entity, Array<Operand> operands, CallArgumentErrorMode show_error_mode, CallArgumentData *data) +#define CALL_ARGUMENT_CHECKER(name) CallArgumentError name(CheckerContext *c, AstNode *call, Type *proc_type, Entity *entity, Array<Operand> operands, CallArgumentErrorMode show_error_mode, CallArgumentData *data) typedef CALL_ARGUMENT_CHECKER(CallArgumentCheckerType); -void check_expr (Checker *c, Operand *operand, AstNode *expression); -void check_multi_expr (Checker *c, Operand *operand, AstNode *expression); -void check_expr_or_type (Checker *c, Operand *operand, AstNode *expression, Type *type_hint = nullptr); -ExprKind check_expr_base (Checker *c, Operand *operand, AstNode *expression, Type *type_hint); -void check_expr_with_type_hint (Checker *c, Operand *o, AstNode *e, Type *t); -Type * check_type (Checker *c, AstNode *expression); -Type * check_type_expr (Checker *c, AstNode *expression, Type *named_type); +void check_expr (CheckerContext *c, Operand *operand, AstNode *expression); +void check_multi_expr (CheckerContext *c, Operand *operand, AstNode *expression); +void check_expr_or_type (CheckerContext *c, Operand *operand, AstNode *expression, Type *type_hint = nullptr); +ExprKind check_expr_base (CheckerContext *c, Operand *operand, AstNode *expression, Type *type_hint); +void check_expr_with_type_hint (CheckerContext *c, Operand *o, AstNode *e, Type *t); +Type * check_type (CheckerContext *c, AstNode *expression); +Type * check_type_expr (CheckerContext *c, AstNode *expression, Type *named_type); Type * make_optional_ok_type (Type *value); -void check_type_decl (Checker *c, Entity *e, AstNode *type_expr, Type *def); -Entity * check_selector (Checker *c, Operand *operand, AstNode *node, Type *type_hint); -Entity * check_ident (Checker *c, Operand *o, AstNode *n, Type *named_type, Type *type_hint, bool allow_import_name); -Entity * find_polymorphic_struct_entity (Checker *c, Type *original_type, isize param_count, Array<Operand> ordered_operands); -void check_not_tuple (Checker *c, Operand *operand); -void convert_to_typed (Checker *c, Operand *operand, Type *target_type); +void check_type_decl (CheckerContext *c, Entity *e, AstNode *type_expr, Type *def); +Entity * check_selector (CheckerContext *c, Operand *operand, AstNode *node, Type *type_hint); +Entity * check_ident (CheckerContext *c, Operand *o, AstNode *n, Type *named_type, Type *type_hint, bool allow_import_name); +Entity * find_polymorphic_struct_entity (CheckerContext *c, Type *original_type, isize param_count, Array<Operand> ordered_operands); +void check_not_tuple (CheckerContext *c, Operand *operand); +void convert_to_typed (CheckerContext *c, Operand *operand, Type *target_type); gbString expr_to_string (AstNode *expression); -void check_entity_decl (Checker *c, Entity *e, DeclInfo *decl, Type *named_type); -void check_const_decl (Checker *c, Entity *e, AstNode *type_expr, AstNode *init_expr, Type *named_type); -void check_proc_body (Checker *c, Token token, DeclInfo *decl, Type *type, AstNode *body); -void update_expr_type (Checker *c, AstNode *e, Type *type, bool final); +void check_entity_decl (CheckerContext *c, Entity *e, DeclInfo *decl, Type *named_type); +void check_const_decl (CheckerContext *c, Entity *e, AstNode *type_expr, AstNode *init_expr, Type *named_type); +void check_proc_body (CheckerContext *c, Token token, DeclInfo *decl, Type *type, AstNode *body); +void update_expr_type (CheckerContext *c, AstNode *e, Type *type, bool final); bool check_is_terminating (AstNode *node); bool check_has_break (AstNode *stmt, bool implicit); -void check_stmt (Checker *c, AstNode *node, u32 flags); -void check_stmt_list (Checker *c, Array<AstNode *> stmts, u32 flags); -void check_init_constant (Checker *c, Entity *e, Operand *operand); -bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type, ExactValue *out_value); -bool check_procedure_type (Checker *c, Type *type, AstNode *proc_type_node, Array<Operand> *operands = nullptr); -void check_struct_type (Checker *c, Type *struct_type, AstNode *node, Array<Operand> *poly_operands, +void check_stmt (CheckerContext *c, AstNode *node, u32 flags); +void check_stmt_list (CheckerContext *c, Array<AstNode *> stmts, u32 flags); +void check_init_constant (CheckerContext *c, Entity *e, Operand *operand); +bool check_representable_as_constant(CheckerContext *c, ExactValue in_value, Type *type, ExactValue *out_value); +bool check_procedure_type (CheckerContext *c, Type *type, AstNode *proc_type_node, Array<Operand> *operands = nullptr); +void check_struct_type (CheckerContext *c, Type *struct_type, AstNode *node, Array<Operand> *poly_operands, Type *named_type = nullptr, Type *original_type_for_poly = nullptr); -CallArgumentData check_call_arguments (Checker *c, Operand *operand, Type *proc_type, AstNode *call); -Type * check_init_variable (Checker *c, Entity *e, Operand *operand, String context_name); +CallArgumentData check_call_arguments (CheckerContext *c, Operand *operand, Type *proc_type, AstNode *call); +Type * check_init_variable (CheckerContext *c, Entity *e, Operand *operand, String context_name); @@ -107,8 +107,8 @@ void error_operand_no_value(Operand *o) { } -void check_scope_decls(Checker *c, Array<AstNode *> nodes, isize reserve_size) { - Scope *s = c->context.scope; +void check_scope_decls(CheckerContext *c, Array<AstNode *> nodes, isize reserve_size) { + Scope *s = c->scope; GB_ASSERT(s->package == nullptr); check_collect_entities(c, nodes); @@ -123,7 +123,7 @@ void check_scope_decls(Checker *c, Array<AstNode *> nodes, isize reserve_size) { default: continue; } - DeclInfo *d = decl_info_of_entity(&c->info, e); + DeclInfo *d = decl_info_of_entity(&c->checker->info, e); if (d != nullptr) { check_entity_decl(c, e, d, nullptr); } @@ -165,7 +165,7 @@ bool check_is_assignable_to_using_subtype(Type *src, Type *dst) { return false; } -bool find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity, Type *type, +bool find_or_generate_polymorphic_procedure(CheckerContext *c, Entity *base_entity, Type *type, Array<Operand> *param_operands, PolyProcData *poly_proc_data) { /////////////////////////////////////////////////////////////////////////////// // // @@ -211,7 +211,7 @@ bool find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity, Typ } - DeclInfo *old_decl = decl_info_of_entity(&c->info, base_entity); + DeclInfo *old_decl = decl_info_of_entity(&c->checker->info, base_entity); if (old_decl == nullptr) { return false; } @@ -239,39 +239,38 @@ bool find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity, Typ - CheckerContext prev_context = c->context; - defer (c->context = prev_context); + CheckerContext nctx = *c; Scope *scope = create_scope(base_entity->scope, a); scope->is_proc = true; - c->context.scope = scope; - c->context.allow_polymorphic_types = true; - if (c->context.polymorphic_scope == nullptr) { - c->context.polymorphic_scope = scope; + nctx.scope = scope; + nctx.allow_polymorphic_types = true; + if (nctx.polymorphic_scope == nullptr) { + nctx.polymorphic_scope = scope; } if (param_operands == nullptr) { - // c->context.no_polymorphic_errors = false; + // c->no_polymorphic_errors = false; } - bool generate_type_again = c->context.no_polymorphic_errors; + bool generate_type_again = nctx.no_polymorphic_errors; auto *pt = &src->Proc; // NOTE(bill): This is slightly memory leaking if the type already exists // Maybe it's better to check with the previous types first? Type *final_proc_type = alloc_type_proc(scope, nullptr, 0, nullptr, 0, false, pt->calling_convention); - bool success = check_procedure_type(c, final_proc_type, pt->node, &operands); + bool success = check_procedure_type(&nctx, final_proc_type, pt->node, &operands); if (!success) { return false; } - gb_mutex_lock(&c->mutex); - defer (gb_mutex_unlock(&c->mutex)); + gb_mutex_lock(&nctx.checker->mutex); + defer (gb_mutex_unlock(&nctx.checker->mutex)); - auto *found_gen_procs = map_get(&c->info.gen_procs, hash_pointer(base_entity->identifier)); + auto *found_gen_procs = map_get(&nctx.checker->info.gen_procs, hash_pointer(base_entity->identifier)); if (found_gen_procs) { auto procs = *found_gen_procs; for_array(i, procs) { @@ -289,14 +288,14 @@ bool find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity, Typ if (generate_type_again) { // LEAK TODO(bill): This is technically a memory leak as it has to generate the type twice - bool prev_no_polymorphic_errors = c->context.no_polymorphic_errors; - defer (c->context.no_polymorphic_errors = prev_no_polymorphic_errors); - c->context.no_polymorphic_errors = false; + bool prev_no_polymorphic_errors = nctx.no_polymorphic_errors; + defer (nctx.no_polymorphic_errors = prev_no_polymorphic_errors); + nctx.no_polymorphic_errors = false; // NOTE(bill): Reset scope from the failed procedure type scope_reset(scope); - success = check_procedure_type(c, final_proc_type, pt->node, &operands); + success = check_procedure_type(&nctx, final_proc_type, pt->node, &operands); if (!success) { return false; @@ -322,25 +321,25 @@ bool find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity, Typ AstNode *proc_lit = clone_ast_node(a, old_decl->proc_lit); ast_node(pl, ProcLit, proc_lit); // NOTE(bill): Associate the scope declared above withinth this procedure declaration's type - add_scope(c, pl->type, final_proc_type->Proc.scope); + add_scope(&nctx, pl->type, final_proc_type->Proc.scope); final_proc_type->Proc.is_poly_specialized = true; final_proc_type->Proc.is_polymorphic = true; u64 tags = base_entity->Procedure.tags; AstNode *ident = clone_ast_node(a, base_entity->identifier); Token token = ident->Ident.token; - DeclInfo *d = make_decl_info(c->allocator, scope, old_decl->parent); + DeclInfo *d = make_decl_info(nctx.allocator, scope, old_decl->parent); d->gen_proc_type = final_proc_type; d->type_expr = pl->type; d->proc_lit = proc_lit; - Entity *entity = alloc_entity_procedure(nullptr, token, final_proc_type, tags); entity->identifier = ident; - add_entity_and_decl_info(c, ident, entity, d); + add_entity_and_decl_info(&nctx, ident, entity, d); // NOTE(bill): Set the scope afterwards as this is not real overloading entity->scope = scope->parent; + entity->pkg = base_entity->pkg; AstFile *file = nullptr; { @@ -365,7 +364,7 @@ bool find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity, Typ } else { auto array = array_make<Entity *>(heap_allocator()); array_add(&array, entity); - map_set(&c->info.gen_procs, hash_pointer(base_entity->identifier), array); + map_set(&nctx.checker->info.gen_procs, hash_pointer(base_entity->identifier), array); } GB_ASSERT(entity != nullptr); @@ -376,27 +375,27 @@ bool find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity, Typ } // NOTE(bill): Check the newly generated procedure body - check_procedure_later(c, proc_info); + check_procedure_later(nctx.checker, proc_info); return true; } -bool check_polymorphic_procedure_assignment(Checker *c, Operand *operand, Type *type, PolyProcData *poly_proc_data) { +bool check_polymorphic_procedure_assignment(CheckerContext *c, Operand *operand, Type *type, PolyProcData *poly_proc_data) { if (operand->expr == nullptr) return false; - Entity *base_entity = entity_of_ident(&c->info, operand->expr); + Entity *base_entity = entity_of_ident(&c->checker->info, operand->expr); if (base_entity == nullptr) return false; return find_or_generate_polymorphic_procedure(c, base_entity, type, nullptr, poly_proc_data); } -bool find_or_generate_polymorphic_procedure_from_parameters(Checker *c, Entity *base_entity, Array<Operand> *operands, PolyProcData *poly_proc_data) { +bool find_or_generate_polymorphic_procedure_from_parameters(CheckerContext *c, Entity *base_entity, Array<Operand> *operands, PolyProcData *poly_proc_data) { return find_or_generate_polymorphic_procedure(c, base_entity, nullptr, operands, poly_proc_data); } -bool check_type_specialization_to(Checker *c, Type *specialization, Type *type, bool compound, bool modify_type); -bool is_polymorphic_type_assignable(Checker *c, Type *poly, Type *source, bool compound, bool modify_type); -bool check_cast_internal(Checker *c, Operand *x, Type *type); +bool check_type_specialization_to(CheckerContext *c, Type *specialization, Type *type, bool compound, bool modify_type); +bool is_polymorphic_type_assignable(CheckerContext *c, Type *poly, Type *source, bool compound, bool modify_type); +bool check_cast_internal(CheckerContext *c, Operand *x, Type *type); -i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) { +i64 check_distance_between_types(CheckerContext *c, Operand *operand, Type *type) { if (operand->mode == Addressing_Invalid || type == t_invalid) { return -1; @@ -529,7 +528,7 @@ i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) { #endif if (is_type_polymorphic(dst) && !is_type_polymorphic(src)) { - bool modify_type = !c->context.no_polymorphic_errors; + bool modify_type = !c->no_polymorphic_errors; if (is_polymorphic_type_assignable(c, type, s, false, modify_type)) { return 2; } @@ -595,7 +594,7 @@ i64 assign_score_function(i64 distance) { } -bool check_is_assignable_to_with_score(Checker *c, Operand *operand, Type *type, i64 *score_) { +bool check_is_assignable_to_with_score(CheckerContext *c, Operand *operand, Type *type, i64 *score_) { i64 score = 0; i64 distance = check_distance_between_types(c, operand, type); bool ok = distance >= 0; @@ -607,14 +606,14 @@ bool check_is_assignable_to_with_score(Checker *c, Operand *operand, Type *type, } -bool check_is_assignable_to(Checker *c, Operand *operand, Type *type) { +bool check_is_assignable_to(CheckerContext *c, Operand *operand, Type *type) { i64 score = 0; return check_is_assignable_to_with_score(c, operand, type, &score); } // NOTE(bill): 'content_name' is for debugging and error messages -void check_assignment(Checker *c, Operand *operand, Type *type, String context_name) { +void check_assignment(CheckerContext *c, Operand *operand, Type *type, String context_name) { check_not_tuple(c, operand); if (operand->mode == Addressing_Invalid) { return; @@ -742,7 +741,7 @@ void check_assignment(Checker *c, Operand *operand, Type *type, String context_n } } -bool is_polymorphic_type_assignable(Checker *c, Type *poly, Type *source, bool compound, bool modify_type) { +bool is_polymorphic_type_assignable(CheckerContext *c, Type *poly, Type *source, bool compound, bool modify_type) { Operand o = {Addressing_Value}; o.type = source; switch (poly->kind) { @@ -903,17 +902,17 @@ bool is_polymorphic_type_assignable(Checker *c, Type *poly, Type *source, bool c return false; } -bool check_cycle(Checker *c, Entity *curr, bool report) { +bool check_cycle(CheckerContext *c, Entity *curr, bool report) { if (curr->state != EntityState_InProgress) { return false; } - for_array(i, *c->context.type_path) { - Entity *prev = (*c->context.type_path)[i]; + for_array(i, *c->type_path) { + Entity *prev = (*c->type_path)[i]; if (prev == curr) { if (report) { error(curr->token, "Illegal declaration cycle of `%.*s`", LIT(curr->token.string)); - for (isize j = i; j < c->context.type_path->count; j++) { - Entity *curr = (*c->context.type_path)[j]; + for (isize j = i; j < c->type_path->count; j++) { + Entity *curr = (*c->type_path)[j]; error(curr->token, "\t%.*s refers to", LIT(curr->token.string)); } error(curr->token, "\t%.*s", LIT(curr->token.string)); @@ -925,13 +924,13 @@ bool check_cycle(Checker *c, Entity *curr, bool report) { } -Entity *check_ident(Checker *c, Operand *o, AstNode *n, Type *named_type, Type *type_hint, bool allow_import_name) { +Entity *check_ident(CheckerContext *c, Operand *o, AstNode *n, Type *named_type, Type *type_hint, bool allow_import_name) { GB_ASSERT(n->kind == AstNode_Ident); o->mode = Addressing_Invalid; o->expr = n; String name = n->Ident.token.string; - Entity *e = scope_lookup_entity(c->context.scope, name); + Entity *e = scope_lookup_entity(c->scope, name); if (e == nullptr) { if (is_blank_ident(name)) { error(n, "'_' cannot be used as a value type"); @@ -946,7 +945,7 @@ Entity *check_ident(Checker *c, Operand *o, AstNode *n, Type *named_type, Type * return nullptr; } if (e->parent_proc_decl != nullptr && - e->parent_proc_decl != c->context.curr_proc_decl) { + e->parent_proc_decl != c->curr_proc_decl) { if (e->kind == Entity_Variable) { error(n, "Nested procedures do not capture its parent's variables: %.*s", LIT(name)); return nullptr; @@ -967,7 +966,7 @@ Entity *check_ident(Checker *c, Operand *o, AstNode *n, Type *named_type, Type * if (e->kind == Entity_ProcGroup) { auto *pge = &e->ProcGroup; - DeclInfo *d = decl_info_of_entity(&c->info, e); + DeclInfo *d = decl_info_of_entity(&c->checker->info, e); check_entity_decl(c, e, d, nullptr); @@ -1087,7 +1086,7 @@ Entity *check_ident(Checker *c, Operand *o, AstNode *n, Type *named_type, Type * } -bool check_unary_op(Checker *c, Operand *o, Token op) { +bool check_unary_op(CheckerContext *c, Operand *o, Token op) { if (o->type == nullptr) { gbString str = expr_to_string(o->expr); error(o->expr, "Expression has no value '%s'", str); @@ -1129,7 +1128,7 @@ bool check_unary_op(Checker *c, Operand *o, Token op) { return true; } -bool check_binary_op(Checker *c, Operand *o, Token op) { +bool check_binary_op(CheckerContext *c, Operand *o, Token op) { // TODO(bill): Handle errors correctly Type *type = base_type(core_array_type(o->type)); switch (op.kind) { @@ -1225,7 +1224,7 @@ bool check_binary_op(Checker *c, Operand *o, Token op) { } -bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type, ExactValue *out_value) { +bool check_representable_as_constant(CheckerContext *c, ExactValue in_value, Type *type, ExactValue *out_value) { if (in_value.kind == ExactValue_Invalid) { // NOTE(bill): There's already been an error return true; @@ -1340,7 +1339,7 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type return false; } -void check_is_expressible(Checker *c, Operand *o, Type *type) { +void check_is_expressible(CheckerContext *c, Operand *o, Type *type) { GB_ASSERT(is_type_constant_type(type)); GB_ASSERT(o->mode == Addressing_Constant); if (!check_representable_as_constant(c, o->value, type, &o->value)) { @@ -1370,14 +1369,14 @@ void check_is_expressible(Checker *c, Operand *o, Type *type) { } } -bool check_is_not_addressable(Checker *c, Operand *o) { +bool check_is_not_addressable(CheckerContext *c, Operand *o) { if (o->mode == Addressing_OptionalOk) { AstNode *expr = unselector_expr(o->expr); if (expr->kind != AstNode_TypeAssertion) { return true; } ast_node(ta, TypeAssertion, expr); - TypeAndValue tv = type_and_value_of_expr(&c->info, ta->expr); + TypeAndValue tv = type_and_value_of_expr(&c->checker->info, ta->expr); if (is_type_pointer(tv.type)) { return false; } @@ -1400,7 +1399,7 @@ bool check_is_not_addressable(Checker *c, Operand *o) { return false; } -void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) { +void check_unary_expr(CheckerContext *c, Operand *o, Token op, AstNode *node) { switch (op.kind) { case Token_And: { // Pointer address if (check_is_not_addressable(c, o)) { @@ -1471,7 +1470,7 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) { } -void check_comparison(Checker *c, Operand *x, Operand *y, TokenKind op) { +void check_comparison(CheckerContext *c, Operand *x, Operand *y, TokenKind op) { if (x->mode == Addressing_Type && y->mode == Addressing_Type) { bool comp = are_types_identical(x->type, y->type); switch (op) { @@ -1585,7 +1584,7 @@ void check_comparison(Checker *c, Operand *x, Operand *y, TokenKind op) { } -void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { +void check_shift(CheckerContext *c, Operand *x, Operand *y, AstNode *node) { GB_ASSERT(node->kind == AstNode_BinaryExpr); ast_node(be, BinaryExpr, node); @@ -1656,7 +1655,7 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { TokenPos pos = ast_node_token(x->expr).pos; if (x_is_untyped) { - ExprInfo *info = check_get_expr_info(&c->info, x->expr); + ExprInfo *info = check_get_expr_info(&c->checker->info, x->expr); if (info != nullptr) { info->is_lhs = true; } @@ -1684,7 +1683,7 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { } -Operand check_ptr_addition(Checker *c, TokenKind op, Operand *ptr, Operand *offset, AstNode *node) { +Operand check_ptr_addition(CheckerContext *c, TokenKind op, Operand *ptr, Operand *offset, AstNode *node) { GB_ASSERT(node->kind == AstNode_BinaryExpr); ast_node(be, BinaryExpr, node); GB_ASSERT(is_type_pointer(ptr->type)); @@ -1741,7 +1740,7 @@ Operand check_ptr_addition(Checker *c, TokenKind op, Operand *ptr, Operand *offs -bool check_is_castable_to(Checker *c, Operand *operand, Type *y) { +bool check_is_castable_to(CheckerContext *c, Operand *operand, Type *y) { if (check_is_assignable_to(c, operand, y)) { return true; } @@ -1865,7 +1864,7 @@ bool check_is_castable_to(Checker *c, Operand *operand, Type *y) { return false; } -bool check_cast_internal(Checker *c, Operand *x, Type *type) { +bool check_cast_internal(CheckerContext *c, Operand *x, Type *type) { bool is_const_expr = x->mode == Addressing_Constant; bool can_convert = false; @@ -1890,7 +1889,7 @@ bool check_cast_internal(Checker *c, Operand *x, Type *type) { } -void check_cast(Checker *c, Operand *x, Type *type) { +void check_cast(CheckerContext *c, Operand *x, Type *type) { if (!is_operand_value(*x)) { error(x->expr, "Only values can be casted"); x->mode = Addressing_Invalid; @@ -1924,7 +1923,7 @@ void check_cast(Checker *c, Operand *x, Type *type) { x->type = type; } -bool check_transmute(Checker *c, AstNode *node, Operand *o, Type *t) { +bool check_transmute(CheckerContext *c, AstNode *node, Operand *o, Type *t) { if (!is_operand_value(*o)) { error(o->expr, "'transmute' can only be applied to values"); o->mode = Addressing_Invalid; @@ -1967,7 +1966,7 @@ bool check_transmute(Checker *c, AstNode *node, Operand *o, Type *t) { return true; } -bool check_binary_array_expr(Checker *c, Token op, Operand *x, Operand *y) { +bool check_binary_array_expr(CheckerContext *c, Token op, Operand *x, Operand *y) { if (is_type_array(x->type) && !is_type_array(y->type)) { if (check_is_assignable_to(c, y, x->type)) { if (check_binary_op(c, x, op)) { @@ -1979,7 +1978,7 @@ bool check_binary_array_expr(Checker *c, Token op, Operand *x, Operand *y) { } -void check_binary_expr(Checker *c, Operand *x, AstNode *node) { +void check_binary_expr(CheckerContext *c, Operand *x, AstNode *node) { GB_ASSERT(node->kind == AstNode_BinaryExpr); Operand y_ = {}, *y = &y_; @@ -2167,8 +2166,8 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { } -void update_expr_type(Checker *c, AstNode *e, Type *type, bool final) { - ExprInfo *found = check_get_expr_info(&c->info, e); +void update_expr_type(CheckerContext *c, AstNode *e, Type *type, bool final) { + ExprInfo *found = check_get_expr_info(&c->checker->info, e); if (found == nullptr) { return; } @@ -2207,12 +2206,12 @@ void update_expr_type(Checker *c, AstNode *e, Type *type, bool final) { if (!final && is_type_untyped(type)) { old.type = base_type(type); - check_set_expr_info(&c->info, e, old); + check_set_expr_info(&c->checker->info, e, old); return; } // We need to remove it and then give it a new one - check_remove_expr_info(&c->info, e); + check_remove_expr_info(&c->checker->info, e); if (old.is_lhs && !is_type_integer(type)) { gbString expr_str = expr_to_string(e); @@ -2223,17 +2222,17 @@ void update_expr_type(Checker *c, AstNode *e, Type *type, bool final) { return; } - add_type_and_value(&c->info, e, old.mode, type, old.value); + add_type_and_value(&c->checker->info, e, old.mode, type, old.value); } -void update_expr_value(Checker *c, AstNode *e, ExactValue value) { - ExprInfo *found = check_get_expr_info(&c->info, e); +void update_expr_value(CheckerContext *c, AstNode *e, ExactValue value) { + ExprInfo *found = check_get_expr_info(&c->checker->info, e); if (found) { found->value = value; } } -void convert_untyped_error(Checker *c, Operand *operand, Type *target_type) { +void convert_untyped_error(CheckerContext *c, Operand *operand, Type *target_type) { gbString expr_str = expr_to_string(operand->expr); gbString type_str = type_to_string(target_type); char *extra_text = ""; @@ -2269,7 +2268,7 @@ ExactValue convert_exact_value_for_type(ExactValue v, Type *type) { return v; } -void convert_to_typed(Checker *c, Operand *operand, Type *target_type) { +void convert_to_typed(CheckerContext *c, Operand *operand, Type *target_type) { GB_ASSERT_NOT_NULL(target_type); if (operand->mode == Addressing_Invalid || operand->mode == Addressing_Type || @@ -2464,7 +2463,7 @@ void convert_to_typed(Checker *c, Operand *operand, Type *target_type) { update_expr_type(c, operand->expr, target_type, true); } -bool check_index_value(Checker *c, bool open_range, AstNode *index_value, i64 max_count, i64 *value) { +bool check_index_value(CheckerContext *c, bool open_range, AstNode *index_value, i64 max_count, i64 *value) { Operand operand = {Addressing_Invalid}; check_expr(c, &operand, index_value); if (operand.mode == Addressing_Invalid) { @@ -2487,7 +2486,7 @@ bool check_index_value(Checker *c, bool open_range, AstNode *index_value, i64 ma } if (operand.mode == Addressing_Constant && - (c->context.stmt_state_flags & StmtStateFlag_no_bounds_check) == 0) { + (c->stmt_state_flags & StmtStateFlag_no_bounds_check) == 0) { i64 i = exact_value_to_integer(operand.value).value_integer; if (i < 0) { gbString expr_str = expr_to_string(operand.expr); @@ -2522,7 +2521,7 @@ bool check_index_value(Checker *c, bool open_range, AstNode *index_value, i64 ma return true; } -Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_hint) { +Entity *check_selector(CheckerContext *c, Operand *operand, AstNode *node, Type *type_hint) { ast_node(se, SelectorExpr, node); bool check_op_expr = true; @@ -2550,7 +2549,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h if (op_expr->kind == AstNode_Ident) { String op_name = op_expr->Ident.token.string; - Entity *e = scope_lookup_entity(c->context.scope, op_name); + Entity *e = scope_lookup_entity(c->scope, op_name); bool is_alias = false; while (e != nullptr && e->kind == Entity_Alias) { @@ -2813,7 +2812,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h return entity; } -bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id) { +bool check_builtin_procedure(CheckerContext *c, Operand *operand, AstNode *call, i32 id) { GB_ASSERT(call->kind == AstNode_CallExpr); ast_node(ce, CallExpr, call); BuiltinProc *bp = &builtin_procs[id]; @@ -3365,7 +3364,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return false; } // NOTE(bill): Prevent type cycles for procedure declarations - if (c->context.curr_proc_sig == o.type) { + if (c->curr_proc_sig == o.type) { gbString s = expr_to_string(o.expr); error(o.expr, "Invalid cyclic type usage from 'type_of', got '%s'", s); gb_string_free(s); @@ -3383,12 +3382,12 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case BuiltinProc_type_info_of: { // proc type_info_of(Type) -> ^Type_Info - if (c->context.scope->is_global) { + if (c->scope->is_global) { compiler_error("'type_info_of' Cannot be declared within a #shared_global_scope due to how the internals of the compiler works"); } // NOTE(bill): The type information may not be setup yet - init_preload(c); + init_preload(c->checker); AstNode *expr = ce->args[0]; Operand o = {}; check_expr_or_type(c, &o, expr); @@ -3418,12 +3417,12 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case BuiltinProc_typeid_of: { // proc typeid_of(Type) -> typeid - if (c->context.scope->is_global) { + if (c->scope->is_global) { compiler_error("'typeid_of' Cannot be declared within a #shared_global_scope due to how the internals of the compiler works"); } // NOTE(bill): The type information may not be setup yet - init_preload(c); + init_preload(c->checker); AstNode *expr = ce->args[0]; Operand o = {}; check_expr_or_type(c, &o, expr); @@ -4086,13 +4085,13 @@ break; } -isize add_dependencies_from_unpacking(Checker *c, Entity **lhs, isize lhs_count, isize tuple_index, isize tuple_count) { +isize add_dependencies_from_unpacking(CheckerContext *c, Entity **lhs, isize lhs_count, isize tuple_index, isize tuple_count) { if (lhs != nullptr) { for (isize j = 0; (tuple_index + j) < lhs_count && j < tuple_count; j++) { Entity *e = lhs[tuple_index + j]; - DeclInfo *decl = decl_info_of_entity(&c->info, e); + DeclInfo *decl = decl_info_of_entity(&c->checker->info, e); if (decl != nullptr) { - c->context.decl = decl; // will be reset by the 'defer' any way + c->decl = decl; // will be reset by the 'defer' any way for_array(k, decl->deps.entries) { Entity *dep = decl->deps.entries[k].ptr; add_declaration_dependency(c, dep); // TODO(bill): Should this be here? @@ -4104,12 +4103,12 @@ isize add_dependencies_from_unpacking(Checker *c, Entity **lhs, isize lhs_count, } -void check_unpack_arguments(Checker *c, Entity **lhs, isize lhs_count, Array<Operand> *operands, Array<AstNode *> rhs, bool allow_ok, bool *optional_ok_ = nullptr) { +void check_unpack_arguments(CheckerContext *ctx, Entity **lhs, isize lhs_count, Array<Operand> *operands, Array<AstNode *> rhs, bool allow_ok, bool *optional_ok_ = nullptr) { bool optional_ok = false; isize tuple_index = 0; for_array(i, rhs) { - CheckerContext prev_context = c->context; - defer (c->context = prev_context); + CheckerContext c_ = *ctx; + CheckerContext *c = &c_; Operand o = {}; @@ -4118,8 +4117,8 @@ void check_unpack_arguments(Checker *c, Entity **lhs, isize lhs_count, Array<Ope if (lhs != nullptr && tuple_index < lhs_count) { // NOTE(bill): override DeclInfo for dependency Entity *e = lhs[tuple_index]; - DeclInfo *decl = decl_info_of_entity(&c->info, e); - if (decl) c->context.decl = decl; + DeclInfo *decl = decl_info_of_entity(&c->checker->info, e); + if (decl) c->decl = decl; type_hint = e->type; } @@ -4134,7 +4133,7 @@ void check_unpack_arguments(Checker *c, Entity **lhs, isize lhs_count, Array<Ope if (allow_ok && lhs_count == 2 && rhs.count == 1 && (o.mode == Addressing_MapIndex || o.mode == Addressing_OptionalOk)) { Type *tuple = make_optional_ok_type(o.type); - add_type_and_value(&c->info, o.expr, o.mode, tuple, o.value); + add_type_and_value(&c->checker->info, o.expr, o.mode, tuple, o.value); Operand val = o; Operand ok = o; @@ -4547,7 +4546,7 @@ CALL_ARGUMENT_CHECKER(check_named_call_arguments) { return err; } -CallArgumentData check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNode *call) { +CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type *proc_type, AstNode *call) { ast_node(ce, CallExpr, call); CallArgumentCheckerType *call_checker = check_call_arguments_internal; @@ -4595,12 +4594,12 @@ CallArgumentData check_call_arguments(Checker *c, Operand *operand, Type *proc_t if (pt != nullptr && is_type_proc(pt)) { CallArgumentError err = CallArgumentError_None; CallArgumentData data = {}; - CheckerContext prev_context = c->context; - defer (c->context = prev_context); - c->context.no_polymorphic_errors = true; - c->context.allow_polymorphic_types = is_type_polymorphic(pt); + CheckerContext ctx = *c; + + ctx.no_polymorphic_errors = true; + ctx.allow_polymorphic_types = is_type_polymorphic(pt); - err = call_checker(c, call, pt, p, operands, CallArgumentMode_NoErrors, &data); + err = call_checker(&ctx, call, pt, p, operands, CallArgumentMode_NoErrors, &data); if (err == CallArgumentError_None) { valids[valid_count].index = i; @@ -4723,7 +4722,7 @@ CallArgumentData check_call_arguments(Checker *c, Operand *operand, Type *proc_t ident = s; } - Entity *e = entity_of_ident(&c->info, ident); + Entity *e = entity_of_ident(&c->checker->info, ident); CallArgumentData data = {}; CallArgumentError err = call_checker(c, call, proc_type, e, operands, CallArgumentMode_ShowErrors, &data); Entity *entity_to_use = data.gen_entity != nullptr ? data.gen_entity : e; @@ -4755,7 +4754,7 @@ isize lookup_polymorphic_struct_parameter(TypeStruct *st, String parameter_name) } -CallArgumentError check_polymorphic_struct_type(Checker *c, Operand *operand, AstNode *call) { +CallArgumentError check_polymorphic_struct_type(CheckerContext *c, Operand *operand, AstNode *call) { ast_node(ce, CallExpr, call); Type *original_type = operand->type; @@ -4945,7 +4944,7 @@ CallArgumentError check_polymorphic_struct_type(Checker *c, Operand *operand, As } -ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { +ExprKind check_call_expr(CheckerContext *c, Operand *operand, AstNode *call) { ast_node(ce, CallExpr, call); if (ce->proc != nullptr && ce->proc->kind == AstNode_BasicDirective) { @@ -4956,7 +4955,7 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { operand->builtin_id = BuiltinProc_DIRECTIVE; operand->expr = ce->proc; operand->type = t_invalid; - add_type_and_value(&c->info, ce->proc, operand->mode, operand->type, operand->value); + add_type_and_value(&c->checker->info, ce->proc, operand->mode, operand->type, operand->value); } else { GB_PANIC("Unhandled #%.*s", LIT(name)); } @@ -5014,7 +5013,7 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { Type *ot = operand->type; GB_ASSERT(ot->kind == Type_Named); Entity *e = ot->Named.type_name; add_entity_use(c, ident, e); - add_type_and_value(&c->info, call, Addressing_Type, ot, empty_exact_value); + add_type_and_value(&c->checker->info, call, Addressing_Type, ot, empty_exact_value); } else { operand->mode = Addressing_Invalid; operand->type = t_invalid; @@ -5122,7 +5121,7 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { } -void check_expr_with_type_hint(Checker *c, Operand *o, AstNode *e, Type *t) { +void check_expr_with_type_hint(CheckerContext *c, Operand *o, AstNode *e, Type *t) { check_expr_base(c, o, e, t); check_not_tuple(c, o); char *err_str = nullptr; @@ -5206,7 +5205,7 @@ bool ternary_compare_types(Type *x, Type *y) { return are_types_identical(x, y); } -ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *type_hint) { +ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, AstNode *node, Type *type_hint) { ExprKind kind = Expr_Stmt; o->mode = Addressing_Invalid; @@ -5223,12 +5222,12 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t case_ast_node(i, Implicit, node) switch (i->kind) { case Token_context: - if (c->context.proc_name.len == 0) { + if (c->proc_name.len == 0) { error(node, "'context' is only allowed within procedures"); return kind; } - init_preload(c); + init_preload(c->checker); o->mode = Addressing_Immutable; o->type = t_context; break; @@ -5299,16 +5298,16 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t o->type = t_untyped_integer; o->value = exact_value_i64(bd->token.pos.line); } else if (bd->name == "procedure") { - if (c->context.curr_proc_decl == nullptr) { + if (c->curr_proc_decl == nullptr) { error(node, "#procedure may only be used within procedures"); o->type = t_untyped_string; o->value = exact_value_string(str_lit("")); } else { o->type = t_untyped_string; - o->value = exact_value_string(c->context.proc_name); + o->value = exact_value_string(c->proc_name); } } else if (bd->name == "caller_location") { - init_preload(c); + init_preload(c->checker); error(node, "#caller_location may only be used as a default argument parameter"); o->type = t_source_code_location; o->mode = Addressing_Value; @@ -5324,26 +5323,27 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t case_end; case_ast_node(pl, ProcLit, node); - CheckerContext prev_context = c->context; + CheckerContext ctx = *c; + DeclInfo *decl = nullptr; Type *type = alloc_type(Type_Proc); - check_open_scope(c, pl->type); + check_open_scope(&ctx, pl->type); { - decl = make_decl_info(c->allocator, c->context.scope, c->context.decl); + decl = make_decl_info(ctx.allocator, ctx.scope, ctx.decl); decl->proc_lit = node; - c->context.decl = decl; + ctx.decl = decl; if (pl->tags != 0) { error(node, "A procedure literal cannot have tags"); pl->tags = 0; // TODO(bill): Should I zero this?! } - check_procedure_type(c, type, pl->type); + check_procedure_type(&ctx, type, pl->type); if (!is_type_proc(type)) { gbString str = expr_to_string(node); error(node, "Invalid procedure literal '%s'", str); gb_string_free(str); - check_close_scope(c); + check_close_scope(&ctx); return kind; } @@ -5352,11 +5352,10 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t return kind; } - check_procedure_later(c, c->context.file, empty_token, decl, type, pl->body, pl->tags); + check_procedure_later(ctx.checker, ctx.file, empty_token, decl, type, pl->body, pl->tags); } - check_close_scope(c); + check_close_scope(&ctx); - c->context = prev_context; o->mode = Addressing_Value; o->type = type; @@ -6210,7 +6209,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t return kind; } -ExprKind check_expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint) { +ExprKind check_expr_base(CheckerContext *c, Operand *o, AstNode *node, Type *type_hint) { ExprKind kind = check_expr_base_internal(c, o, node, type_hint); Type *type = nullptr; ExactValue value = {ExactValue_Invalid}; @@ -6231,16 +6230,16 @@ ExprKind check_expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint) } if (type != nullptr && is_type_untyped(type)) { - add_untyped(&c->info, node, false, o->mode, type, value); + add_untyped(&c->checker->info, node, false, o->mode, type, value); } else { - add_type_and_value(&c->info, node, o->mode, type, value); + add_type_and_value(&c->checker->info, node, o->mode, type, value); } return kind; } -void check_multi_expr(Checker *c, Operand *o, AstNode *e) { +void check_multi_expr(CheckerContext *c, Operand *o, AstNode *e) { check_expr_base(c, o, e, nullptr); switch (o->mode) { default: @@ -6255,7 +6254,7 @@ void check_multi_expr(Checker *c, Operand *o, AstNode *e) { o->mode = Addressing_Invalid; } -void check_not_tuple(Checker *c, Operand *o) { +void check_not_tuple(CheckerContext *c, Operand *o) { if (o->mode == Addressing_Value) { // NOTE(bill): Tuples are not first class thus never named if (o->type->kind == Type_Tuple) { @@ -6268,13 +6267,13 @@ void check_not_tuple(Checker *c, Operand *o) { } } -void check_expr(Checker *c, Operand *o, AstNode *e) { +void check_expr(CheckerContext *c, Operand *o, AstNode *e) { check_multi_expr(c, o, e); check_not_tuple(c, o); } -void check_expr_or_type(Checker *c, Operand *o, AstNode *e, Type *type_hint) { +void check_expr_or_type(CheckerContext *c, Operand *o, AstNode *e, Type *type_hint) { check_expr_base(c, o, e, type_hint); check_not_tuple(c, o); error_operand_no_value(o); diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 8ec5ac9f4..8e6406cc4 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1,10 +1,10 @@ -void check_stmt_list(Checker *c, Array<AstNode *> stmts, u32 flags) { +void check_stmt_list(CheckerContext *ctx, Array<AstNode *> stmts, u32 flags) { if (stmts.count == 0) { return; } if (flags&Stmt_CheckScopeDecls) { - check_scope_decls(c, stmts, cast(isize)(1.2*stmts.count)); + check_scope_decls(ctx, stmts, cast(isize)(1.2*stmts.count)); } bool ft_ok = (flags & Stmt_FallthroughAllowed) != 0; @@ -39,7 +39,7 @@ void check_stmt_list(Checker *c, Array<AstNode *> stmts, u32 flags) { } } - check_stmt(c, n, new_flags); + check_stmt(ctx, n, new_flags); } } @@ -176,7 +176,7 @@ bool check_is_terminating(AstNode *node) { return false; } -Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { +Type *check_assignment_variable(CheckerContext *ctx, Operand *lhs, Operand *rhs) { if (rhs->mode == Addressing_Invalid) { return nullptr; } @@ -190,7 +190,7 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { // NOTE(bill): Ignore assignments to '_' if (is_blank_ident(node)) { - check_assignment(c, rhs, nullptr, str_lit("assignment to '_' identifier")); + check_assignment(ctx, rhs, nullptr, str_lit("assignment to '_' identifier")); if (rhs->mode == Addressing_Invalid) { return nullptr; } @@ -208,7 +208,7 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { } if (rhs->mode == Addressing_ProcGroup) { - Array<Entity *> procs = proc_group_entities(c, *rhs); + Array<Entity *> procs = proc_group_entities(ctx, *rhs); GB_ASSERT(procs.count > 0); // NOTE(bill): These should be done @@ -220,9 +220,9 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { Operand x = {}; x.mode = Addressing_Value; x.type = t; - if (check_is_assignable_to(c, &x, lhs->type)) { + if (check_is_assignable_to(ctx, &x, lhs->type)) { e = procs[i]; - add_entity_use(c, rhs->expr, e); + add_entity_use(ctx, rhs->expr, e); break; } } @@ -236,7 +236,7 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { } else { if (node->kind == AstNode_Ident) { ast_node(i, Ident, node); - e = scope_lookup_entity(c->context.scope, i->token.string); + e = scope_lookup_entity(ctx->scope, i->token.string); if (e != nullptr && e->kind == Entity_Variable) { used = (e->flags & EntityFlag_Used) != 0; // TODO(bill): Make backup just in case } @@ -292,7 +292,7 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { AstNode *ln = unparen_expr(lhs->expr); if (ln->kind == AstNode_IndexExpr) { AstNode *x = ln->IndexExpr.expr; - TypeAndValue tav = type_and_value_of_expr(&c->info, x); + TypeAndValue tav = type_and_value_of_expr(&ctx->checker->info, x); GB_ASSERT(tav.mode != Addressing_Invalid); if (tav.mode != Addressing_Variable) { if (!is_type_pointer(tav.type)) { @@ -312,7 +312,7 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { // NOTE(bill): Extra error checks Operand op_c = {Addressing_Invalid}; ast_node(se, SelectorExpr, lhs->expr); - check_expr(c, &op_c, se->expr); + check_expr(ctx, &op_c, se->expr); if (op_c.mode == Addressing_MapIndex) { gbString str = expr_to_string(lhs->expr); error(lhs->expr, "Cannot assign to struct field '%s' in map", str); @@ -333,7 +333,7 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { } } - check_assignment(c, rhs, assignment_type, str_lit("assignment")); + check_assignment(ctx, rhs, assignment_type, str_lit("assignment")); if (rhs->mode == Addressing_Invalid) { return nullptr; } @@ -342,13 +342,13 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { } -void check_stmt_internal(Checker *c, AstNode *node, u32 flags); -void check_stmt(Checker *c, AstNode *node, u32 flags) { - u32 prev_stmt_state_flags = c->context.stmt_state_flags; +void check_stmt_internal(CheckerContext *ctx, AstNode *node, u32 flags); +void check_stmt(CheckerContext *ctx, AstNode *node, u32 flags) { + u32 prev_stmt_state_flags = ctx->stmt_state_flags; if (node->stmt_state_flags != 0) { u32 in = node->stmt_state_flags; - u32 out = c->context.stmt_state_flags; + u32 out = ctx->stmt_state_flags; if (in & StmtStateFlag_no_bounds_check) { out |= StmtStateFlag_no_bounds_check; @@ -359,18 +359,18 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) { out &= ~StmtStateFlag_no_bounds_check; } - c->context.stmt_state_flags = out; + ctx->stmt_state_flags = out; } - check_stmt_internal(c, node, flags); + check_stmt_internal(ctx, node, flags); - c->context.stmt_state_flags = prev_stmt_state_flags; + ctx->stmt_state_flags = prev_stmt_state_flags; } -void check_when_stmt(Checker *c, AstNodeWhenStmt *ws, u32 flags) { +void check_when_stmt(CheckerContext *ctx, AstNodeWhenStmt *ws, u32 flags) { Operand operand = {Addressing_Invalid}; - check_expr(c, &operand, ws->cond); + check_expr(ctx, &operand, ws->cond); if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) { error(ws->cond, "Non-constant boolean 'when' condition"); return; @@ -381,14 +381,14 @@ void check_when_stmt(Checker *c, AstNodeWhenStmt *ws, u32 flags) { } if (operand.value.kind == ExactValue_Bool && operand.value.value_bool) { - check_stmt_list(c, ws->body->BlockStmt.stmts, flags); + check_stmt_list(ctx, ws->body->BlockStmt.stmts, flags); } else if (ws->else_stmt) { switch (ws->else_stmt->kind) { case AstNode_BlockStmt: - check_stmt_list(c, ws->else_stmt->BlockStmt.stmts, flags); + check_stmt_list(ctx, ws->else_stmt->BlockStmt.stmts, flags); break; case AstNode_WhenStmt: - check_when_stmt(c, &ws->else_stmt->WhenStmt, flags); + check_when_stmt(ctx, &ws->else_stmt->WhenStmt, flags); break; default: error(ws->else_stmt, "Invalid 'else' statement in 'when' statement"); @@ -397,7 +397,7 @@ void check_when_stmt(Checker *c, AstNodeWhenStmt *ws, u32 flags) { } } -void check_label(Checker *c, AstNode *label) { +void check_label(CheckerContext *ctx, AstNode *label) { if (label == nullptr) { return; } @@ -413,15 +413,15 @@ void check_label(Checker *c, AstNode *label) { } - if (c->context.curr_proc_decl == nullptr) { + if (ctx->curr_proc_decl == nullptr) { error(l->name, "A label is only allowed within a procedure"); return; } - GB_ASSERT(c->context.decl != nullptr); + GB_ASSERT(ctx->decl != nullptr); bool ok = true; - for_array(i, c->context.decl->labels) { - BlockLabel bl = c->context.decl->labels[i]; + for_array(i, ctx->decl->labels) { + BlockLabel bl = ctx->decl->labels[i]; if (bl.name == name) { error(label, "Duplicate label with the name '%.*s'", LIT(name)); ok = false; @@ -429,24 +429,24 @@ void check_label(Checker *c, AstNode *label) { } } - Entity *e = alloc_entity_label(c->context.scope, l->name->Ident.token, t_invalid, label); - add_entity(c, c->context.scope, l->name, e); - e->parent_proc_decl = c->context.curr_proc_decl; + Entity *e = alloc_entity_label(ctx->scope, l->name->Ident.token, t_invalid, label); + add_entity(ctx->checker, ctx->scope, l->name, e); + e->parent_proc_decl = ctx->curr_proc_decl; if (ok) { BlockLabel bl = {name, label}; - array_add(&c->context.decl->labels, bl); + array_add(&ctx->decl->labels, bl); } } // Returns 'true' for 'continue', 'false' for 'return' -bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bool is_selector, Entity *e) { +bool check_using_stmt_entity(CheckerContext *ctx, AstNodeUsingStmt *us, AstNode *expr, bool is_selector, Entity *e) { if (e == nullptr) { error(us->token, "'using' applied to an unknown entity"); return true; } - add_entity_use(c, expr, e); + add_entity_use(ctx, expr, e); switch (e->kind) { case Entity_TypeName: { @@ -456,7 +456,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo Entity *f = t->Enum.fields[i]; if (!is_entity_exported(f)) continue; - Entity *found = scope_insert_entity(c->context.scope, f); + Entity *found = scope_insert_entity(ctx->scope, f); if (found != nullptr) { gbString expr_str = expr_to_string(expr); error(us->token, "Namespace collision while 'using' '%s' of: %.*s", expr_str, LIT(found->token.string)); @@ -478,7 +478,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo Entity *decl = scope->elements.entries[i].value; if (!is_entity_exported(decl)) continue; - Entity *found = scope_insert_entity(c->context.scope, decl); + Entity *found = scope_insert_entity(ctx->scope, decl); if (found != nullptr) { gbString expr_str = expr_to_string(expr); error(us->token, @@ -501,13 +501,13 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo Type *t = base_type(type_deref(e->type)); if (t->kind == Type_Struct) { // TODO(bill): Make it work for unions too - Scope *found = scope_of_node(&c->info, t->Struct.node); + Scope *found = scope_of_node(&ctx->checker->info, t->Struct.node); for_array(i, found->elements.entries) { Entity *f = found->elements.entries[i].value; if (f->kind == Entity_Variable) { Entity *uvar = alloc_entity_using_variable(e, f->token, f->type); uvar->using_expr = expr; - Entity *prev = scope_insert_entity(c->context.scope, uvar); + Entity *prev = scope_insert_entity(ctx->scope, uvar); if (prev != nullptr) { gbString expr_str = expr_to_string(expr); error(us->token, "Namespace collision while using '%s' of: '%.*s'", expr_str, LIT(prev->token.string)); @@ -559,7 +559,7 @@ struct TypeAndToken { Token token; }; -void add_constant_switch_case(Checker *c, Map<TypeAndToken> *seen, Operand operand, bool use_expr = true) { +void add_constant_switch_case(CheckerContext *ctx, Map<TypeAndToken> *seen, Operand operand, bool use_expr = true) { if (operand.mode != Addressing_Constant) { return; } @@ -570,8 +570,8 @@ void add_constant_switch_case(Checker *c, Map<TypeAndToken> *seen, Operand opera TypeAndToken *found = map_get(seen, key); if (found != nullptr) { isize count = multi_map_count(seen, key); - TypeAndToken *taps = gb_alloc_array(c->allocator, TypeAndToken, count); - defer (gb_free(c->allocator, taps)); + TypeAndToken *taps = gb_alloc_array(ctx->allocator, TypeAndToken, count); + defer (gb_free(ctx->allocator, taps)); multi_map_get_all(seen, key, taps); for (isize i = 0; i < count; i++) { @@ -600,23 +600,23 @@ void add_constant_switch_case(Checker *c, Map<TypeAndToken> *seen, Operand opera multi_map_insert(seen, key, tap); } -void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { +void check_switch_stmt(CheckerContext *ctx, AstNode *node, u32 mod_flags) { ast_node(ss, SwitchStmt, node); Operand x = {}; mod_flags |= Stmt_BreakAllowed | Stmt_FallthroughAllowed; - check_open_scope(c, node); - defer (check_close_scope(c)); + check_open_scope(ctx, node); + defer (check_close_scope(ctx)); - check_label(c, ss->label); // TODO(bill): What should the label's "scope" be? + check_label(ctx, ss->label); // TODO(bill): What should the label's "scope" be? if (ss->init != nullptr) { - check_stmt(c, ss->init, 0); + check_stmt(ctx, ss->init, 0); } if (ss->tag != nullptr) { - check_expr(c, &x, ss->tag); - check_assignment(c, &x, nullptr, str_lit("switch expression")); + check_expr(ctx, &x, ss->tag); + check_assignment(ctx, &x, nullptr, str_lit("switch expression")); } else { x.mode = Addressing_Constant; x.type = t_bool; @@ -626,7 +626,7 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { token.pos = ast_node_token(ss->body).pos; token.string = str_lit("true"); - x.expr = gb_alloc_item(c->allocator, AstNode); + x.expr = gb_alloc_item(ctx->allocator, AstNode); x.expr->kind = AstNode_Ident; x.expr->Ident.token = token; } @@ -687,14 +687,14 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { ast_node(ie, BinaryExpr, expr); Operand lhs = {}; Operand rhs = {}; - check_expr(c, &lhs, ie->left); + check_expr(ctx, &lhs, ie->left); if (x.mode == Addressing_Invalid) { continue; } if (lhs.mode == Addressing_Invalid) { continue; } - check_expr(c, &rhs, ie->right); + check_expr(ctx, &rhs, ie->right); if (rhs.mode == Addressing_Invalid) { continue; } @@ -711,7 +711,7 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { Operand a = lhs; Operand b = rhs; - check_comparison(c, &a, &x, Token_LtEq); + check_comparison(ctx, &a, &x, Token_LtEq); if (a.mode == Addressing_Invalid) { continue; } @@ -721,7 +721,7 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { default: error(ie->op, "Invalid interval operator"); continue; } - check_comparison(c, &b, &x, op); + check_comparison(ctx, &b, &x, op); if (b.mode == Addressing_Invalid) { continue; } @@ -736,32 +736,32 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { Operand a1 = lhs; Operand b1 = rhs; - check_comparison(c, &a1, &b1, op); + check_comparison(ctx, &a1, &b1, op); if (complete) { error(lhs.expr, "#complete switch statement does not allow ranges"); } - add_constant_switch_case(c, &seen, lhs); + add_constant_switch_case(ctx, &seen, lhs); if (op == Token_LtEq) { - add_constant_switch_case(c, &seen, rhs); + add_constant_switch_case(ctx, &seen, rhs); } } else { Operand y = {}; - check_expr(c, &y, expr); + check_expr(ctx, &y, expr); if (x.mode == Addressing_Invalid || y.mode == Addressing_Invalid) { continue; } - convert_to_typed(c, &y, x.type); + convert_to_typed(ctx, &y, x.type); if (y.mode == Addressing_Invalid) { continue; } // NOTE(bill): the ordering here matters Operand z = y; - check_comparison(c, &z, &x, Token_CmpEq); + check_comparison(ctx, &z, &x, Token_CmpEq); if (z.mode == Addressing_Invalid) { continue; } @@ -772,13 +772,13 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { continue; } - add_constant_switch_case(c, &seen, y); + add_constant_switch_case(ctx, &seen, y); } } - check_open_scope(c, stmt); - check_stmt_list(c, cc->stmts, mod_flags); - check_close_scope(c); + check_open_scope(ctx, stmt); + check_stmt_list(ctx, cc->stmts, mod_flags); + check_close_scope(ctx); } if (complete) { @@ -786,7 +786,7 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { GB_ASSERT(is_type_enum(et)); auto fields = et->Enum.fields; - auto unhandled = array_make<Entity *>(c->allocator, 0, fields.count); + auto unhandled = array_make<Entity *>(ctx->allocator, 0, fields.count); defer (array_free(&unhandled)); for_array(i, fields) { @@ -838,15 +838,15 @@ TypeSwitchKind check_valid_type_switch_type(Type *type) { return TypeSwitch_Invalid; } -void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { +void check_type_switch_stmt(CheckerContext *ctx, AstNode *node, u32 mod_flags) { ast_node(ss, TypeSwitchStmt, node); Operand x = {}; mod_flags |= Stmt_BreakAllowed; - check_open_scope(c, node); - defer (check_close_scope(c)); + check_open_scope(ctx, node); + defer (check_close_scope(ctx)); - check_label(c, ss->label); // TODO(bill): What should the label's "scope" be? + check_label(ctx, ss->label); // TODO(bill): What should the label's "scope" be? if (ss->tag->kind != AstNode_AssignStmt) { error(ss->tag, "Expected an 'in' assignment for this type switch statement"); @@ -866,9 +866,9 @@ void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { AstNode *lhs = as->lhs[0]; AstNode *rhs = as->rhs[0]; - check_expr(c, &x, rhs); - check_assignment(c, &x, nullptr, str_lit("type switch expression")); - add_type_info_type(c, x.type); + check_expr(ctx, &x, rhs); + check_assignment(ctx, &x, nullptr, str_lit("type switch expression")); + add_type_info_type(ctx, x.type); TypeSwitchKind switch_kind = check_valid_type_switch_type(x.type); if (switch_kind == TypeSwitch_Invalid) { @@ -941,7 +941,7 @@ void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { AstNode *type_expr = cc->list[type_index]; if (type_expr != nullptr) { // Otherwise it's a default expression Operand y = {}; - check_expr_or_type(c, &y, type_expr); + check_expr_or_type(ctx, &y, type_expr); if (switch_kind == TypeSwitch_Union) { GB_ASSERT(is_type_union(bt)); @@ -960,10 +960,10 @@ void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { continue; } case_type = y.type; - add_type_info_type(c, y.type); + add_type_info_type(ctx, y.type); } else if (switch_kind == TypeSwitch_Any) { case_type = y.type; - add_type_info_type(c, y.type); + add_type_info_type(ctx, y.type); } else { GB_PANIC("Unknown type to type switch statement"); } @@ -996,19 +996,19 @@ void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { if (case_type == nullptr) { case_type = x.type; } - add_type_info_type(c, case_type); + add_type_info_type(ctx, case_type); - check_open_scope(c, stmt); + check_open_scope(ctx, stmt); { - Entity *tag_var = alloc_entity_variable(c->context.scope, lhs->Ident.token, case_type, false, EntityState_Resolved); + Entity *tag_var = alloc_entity_variable(ctx->scope, lhs->Ident.token, case_type, false, EntityState_Resolved); tag_var->flags |= EntityFlag_Used; tag_var->flags |= EntityFlag_Value; - add_entity(c, c->context.scope, lhs, tag_var); - add_entity_use(c, lhs, tag_var); - add_implicit_entity(c, stmt, tag_var); + add_entity(ctx->checker, ctx->scope, lhs, tag_var); + add_entity_use(ctx, lhs, tag_var); + add_implicit_entity(ctx, stmt, tag_var); } - check_stmt_list(c, cc->stmts, mod_flags); - check_close_scope(c); + check_stmt_list(ctx, cc->stmts, mod_flags); + check_close_scope(ctx); } if (complete) { @@ -1016,7 +1016,7 @@ void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { GB_ASSERT(is_type_union(ut)); auto variants = ut->Union.variants; - auto unhandled = array_make<Type *>(c->allocator, 0, variants.count); + auto unhandled = array_make<Type *>(ctx->allocator, 0, variants.count); defer (array_free(&unhandled)); for_array(i, variants) { @@ -1046,7 +1046,7 @@ void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { } } -void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { +void check_stmt_internal(CheckerContext *ctx, AstNode *node, u32 flags) { u32 mod_flags = flags & (~Stmt_FallthroughAllowed); switch (node->kind) { case_ast_node(_, EmptyStmt, node); case_end; @@ -1055,7 +1055,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_ast_node(es, ExprStmt, node) Operand operand = {Addressing_Invalid}; - ExprKind kind = check_expr_base(c, &operand, es->expr, nullptr); + ExprKind kind = check_expr_base(ctx, &operand, es->expr, nullptr); switch (operand.mode) { case Addressing_Type: { gbString str = type_to_string(operand.type); @@ -1072,7 +1072,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } if (operand.expr->kind == AstNode_CallExpr) { AstNodeCallExpr *ce = &operand.expr->CallExpr; - Type *t = type_of_expr(&c->info, ce->proc); + Type *t = type_of_expr(&ctx->checker->info, ce->proc); if (is_type_proc(t)) { if (t->Proc.require_results) { gbString expr_str = expr_to_string(ce->proc); @@ -1094,7 +1094,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_ast_node(ts, TagStmt, node); // TODO(bill): Tag Statements error(node, "Tag statements are not supported yet"); - check_stmt(c, ts->stmt, flags); + check_stmt(ctx, ts->stmt, flags); case_end; case_ast_node(as, AssignStmt, node); @@ -1110,8 +1110,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { // NOTE(bill): If there is a bad syntax error, rhs > lhs which would mean there would need to be // an extra allocation - auto lhs_operands = array_make<Operand>(c->allocator, lhs_count); - auto rhs_operands = array_make<Operand>(c->allocator, 0, 2*lhs_count); + auto lhs_operands = array_make<Operand>(ctx->allocator, lhs_count); + auto rhs_operands = array_make<Operand>(ctx->allocator, 0, 2*lhs_count); defer (array_free(&lhs_operands)); defer (array_free(&rhs_operands)); @@ -1121,11 +1121,11 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { o->expr = as->lhs[i]; o->mode = Addressing_Value; } else { - check_expr(c, &lhs_operands[i], as->lhs[i]); + check_expr(ctx, &lhs_operands[i], as->lhs[i]); } } - check_unpack_arguments(c, nullptr, lhs_operands.count, &rhs_operands, as->rhs, true); + check_unpack_arguments(ctx, nullptr, lhs_operands.count, &rhs_operands, as->rhs, true); isize rhs_count = rhs_operands.count; for_array(i, rhs_operands) { @@ -1136,7 +1136,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { isize max = gb_min(lhs_count, rhs_count); for (isize i = 0; i < max; i++) { - check_assignment_variable(c, &lhs_operands[i], &rhs_operands[i]); + check_assignment_variable(ctx, &lhs_operands[i], &rhs_operands[i]); } if (lhs_count != rhs_count) { error(as->lhs[0], "Assignment count mismatch '%td' = '%td'", lhs_count, rhs_count); @@ -1165,13 +1165,13 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { be->left = as->lhs[0]; be->right = as->rhs[0]; - check_expr(c, &lhs, as->lhs[0]); - check_binary_expr(c, &rhs, &binary_expr); + check_expr(ctx, &lhs, as->lhs[0]); + check_binary_expr(ctx, &rhs, &binary_expr); if (rhs.mode == Addressing_Invalid) { return; } // NOTE(bill): Only use the first one will be used - check_assignment_variable(c, &lhs, &rhs); + check_assignment_variable(ctx, &lhs, &rhs); break; } @@ -1179,31 +1179,31 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(bs, BlockStmt, node); - check_open_scope(c, node); - check_stmt_list(c, bs->stmts, flags); - check_close_scope(c); + check_open_scope(ctx, node); + check_stmt_list(ctx, bs->stmts, flags); + check_close_scope(ctx); case_end; case_ast_node(is, IfStmt, node); - check_open_scope(c, node); + check_open_scope(ctx, node); if (is->init != nullptr) { - check_stmt(c, is->init, 0); + check_stmt(ctx, is->init, 0); } Operand operand = {Addressing_Invalid}; - check_expr(c, &operand, is->cond); + check_expr(ctx, &operand, is->cond); if (operand.mode != Addressing_Invalid && !is_type_boolean(operand.type)) { error(is->cond, "Non-boolean condition in 'if' statement"); } - check_stmt(c, is->body, mod_flags); + check_stmt(ctx, is->body, mod_flags); if (is->else_stmt != nullptr) { switch (is->else_stmt->kind) { case AstNode_IfStmt: case AstNode_BlockStmt: - check_stmt(c, is->else_stmt, mod_flags); + check_stmt(ctx, is->else_stmt, mod_flags); break; default: error(is->else_stmt, "Invalid 'else' statement in 'if' statement"); @@ -1211,22 +1211,22 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } } - check_close_scope(c); + check_close_scope(ctx); case_end; case_ast_node(ws, WhenStmt, node); - check_when_stmt(c, ws, flags); + check_when_stmt(ctx, ws, flags); case_end; case_ast_node(rs, ReturnStmt, node); - GB_ASSERT(c->context.curr_proc_sig != nullptr); + GB_ASSERT(ctx->curr_proc_sig != nullptr); - if (c->context.in_defer) { + if (ctx->in_defer) { error(rs->token, "You cannot 'return' within a defer statement"); break; } - Type *proc_type = c->context.curr_proc_sig; + Type *proc_type = ctx->curr_proc_sig; GB_ASSERT(proc_type != nullptr); GB_ASSERT(proc_type->kind == Type_Proc); // Type *proc_type = c->proc_stack[c->proc_stack.count-1]; @@ -1241,7 +1241,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { auto operands = array_make<Operand>(heap_allocator(), 0, 2*rs->results.count); defer (array_free(&operands)); - check_unpack_arguments(c, nullptr, -1, &operands, rs->results, false); + check_unpack_arguments(ctx, nullptr, -1, &operands, rs->results, false); if (result_count == 0 && rs->results.count > 0) { error(rs->results[0], "No return values expected"); @@ -1253,7 +1253,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { isize max_count = rs->results.count; for (isize i = 0; i < max_count; i++) { Entity *e = pt->results->Tuple.variables[i]; - check_assignment(c, &operands[i], e->type, str_lit("return statement")); + check_assignment(ctx, &operands[i], e->type, str_lit("return statement")); } } case_end; @@ -1261,37 +1261,37 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_ast_node(fs, ForStmt, node); u32 new_flags = mod_flags | Stmt_BreakAllowed | Stmt_ContinueAllowed; - check_open_scope(c, node); - check_label(c, fs->label); // TODO(bill): What should the label's "scope" be? + check_open_scope(ctx, node); + check_label(ctx, fs->label); // TODO(bill): What should the label's "scope" be? if (fs->init != nullptr) { - check_stmt(c, fs->init, 0); + check_stmt(ctx, fs->init, 0); } if (fs->cond != nullptr) { Operand o = {Addressing_Invalid}; - check_expr(c, &o, fs->cond); + check_expr(ctx, &o, fs->cond); if (o.mode != Addressing_Invalid && !is_type_boolean(o.type)) { error(fs->cond, "Non-boolean condition in 'for' statement"); } } if (fs->post != nullptr) { - check_stmt(c, fs->post, 0); + check_stmt(ctx, fs->post, 0); if (fs->post->kind != AstNode_AssignStmt && fs->post->kind != AstNode_IncDecStmt) { error(fs->post, "'for' statement post statement must be a simple statement"); } } - check_stmt(c, fs->body, new_flags); + check_stmt(ctx, fs->body, new_flags); - check_close_scope(c); + check_close_scope(ctx); case_end; case_ast_node(rs, RangeStmt, node); u32 new_flags = mod_flags | Stmt_BreakAllowed | Stmt_ContinueAllowed; - check_open_scope(c, node); - check_label(c, rs->label); + check_open_scope(ctx, node); + check_label(ctx, rs->label); Type *val0 = nullptr; Type *val1 = nullptr; @@ -1307,29 +1307,29 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Operand x = {Addressing_Invalid}; Operand y = {Addressing_Invalid}; - check_expr(c, &x, ie->left); + check_expr(ctx, &x, ie->left); if (x.mode == Addressing_Invalid) { goto skip_expr; } - check_expr(c, &y, ie->right); + check_expr(ctx, &y, ie->right); if (y.mode == Addressing_Invalid) { goto skip_expr; } - convert_to_typed(c, &x, y.type); + convert_to_typed(ctx, &x, y.type); if (x.mode == Addressing_Invalid) { goto skip_expr; } - convert_to_typed(c, &y, x.type); + convert_to_typed(ctx, &y, x.type); if (y.mode == Addressing_Invalid) { goto skip_expr; } - convert_to_typed(c, &x, default_type(y.type)); + convert_to_typed(ctx, &x, default_type(y.type)); if (x.mode == Addressing_Invalid) { goto skip_expr; } - convert_to_typed(c, &y, default_type(x.type)); + convert_to_typed(ctx, &y, default_type(x.type)); if (y.mode == Addressing_Invalid) { goto skip_expr; } @@ -1383,13 +1383,13 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } - add_type_and_value(&c->info, ie->left, x.mode, x.type, x.value); - add_type_and_value(&c->info, ie->right, y.mode, y.type, y.value); + add_type_and_value(&ctx->checker->info, ie->left, x.mode, x.type, x.value); + add_type_and_value(&ctx->checker->info, ie->right, y.mode, y.type, y.value); val0 = type; val1 = t_int; } else { Operand operand = {Addressing_Invalid}; - check_expr_or_type(c, &operand, rs->expr); + check_expr_or_type(ctx, &operand, rs->expr); if (operand.mode == Addressing_Type) { if (!is_type_enum(operand.type)) { @@ -1400,7 +1400,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } else { val0 = operand.type; val1 = t_int; - add_type_info_type(c, operand.type); + add_type_info_type(ctx, operand.type); goto skip_expr; } } else if (operand.mode != Addressing_Invalid) { @@ -1411,7 +1411,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (is_type_string(t)) { val0 = t_rune; val1 = t_int; - add_package_dependency(c, "runtime", "__string_decode_rune"); + add_package_dependency(ctx, "runtime", "__string_decode_rune"); } break; case Type_Array: @@ -1464,12 +1464,12 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Entity *found = nullptr; if (!is_blank_ident(str)) { - found = current_scope_lookup_entity(c->context.scope, str); + found = current_scope_lookup_entity(ctx->scope, str); } if (found == nullptr) { bool is_immutable = true; - entity = alloc_entity_variable(c->context.scope, token, type, is_immutable, EntityState_Resolved); - add_entity_definition(&c->info, name, entity); + entity = alloc_entity_variable(ctx->scope, token, type, is_immutable, EntityState_Resolved); + add_entity_definition(&ctx->checker->info, name, entity); } else { TokenPos pos = found->token.pos; error(token, @@ -1495,20 +1495,20 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } for (isize i = 0; i < entity_count; i++) { - add_entity(c, c->context.scope, entities[i]->identifier, entities[i]); + add_entity(ctx->checker, ctx->scope, entities[i]->identifier, entities[i]); } - check_stmt(c, rs->body, new_flags); + check_stmt(ctx, rs->body, new_flags); - check_close_scope(c); + check_close_scope(ctx); case_end; case_ast_node(ss, SwitchStmt, node); - check_switch_stmt(c, node, mod_flags); + check_switch_stmt(ctx, node, mod_flags); case_end; case_ast_node(ss, TypeSwitchStmt, node); - check_type_switch_stmt(c, node, mod_flags); + check_type_switch_stmt(ctx, node, mod_flags); case_end; @@ -1516,10 +1516,10 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (is_ast_node_decl(ds->stmt)) { error(ds->token, "You cannot defer a declaration"); } else { - bool out_in_defer = c->context.in_defer; - c->context.in_defer = true; - check_stmt(c, ds->stmt, 0); - c->context.in_defer = out_in_defer; + bool out_in_defer = ctx->in_defer; + ctx->in_defer = true; + check_stmt(ctx, ds->stmt, 0); + ctx->in_defer = out_in_defer; } case_end; @@ -1554,12 +1554,12 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { AstNode *ident = bs->label; String name = ident->Ident.token.string; Operand o = {}; - Entity *e = check_ident(c, &o, ident, nullptr, nullptr, false); + Entity *e = check_ident(ctx, &o, ident, nullptr, nullptr, false); if (e == nullptr) { error(ident, "Undeclared label name: %.*s", LIT(name)); return; } - add_entity_use(c, ident, e); + add_entity_use(ctx, ident, e); if (e->kind != Entity_Label) { error(ident, "'%.*s' is not a label", LIT(name)); return; @@ -1581,10 +1581,10 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Operand o = {}; switch (expr->kind) { case AstNode_Ident: - e = check_ident(c, &o, expr, nullptr, nullptr, true); + e = check_ident(ctx, &o, expr, nullptr, nullptr, true); break; case AstNode_SelectorExpr: - e = check_selector(c, &o, expr, nullptr); + e = check_selector(ctx, &o, expr, nullptr); is_selector = true; break; case AstNode_Implicit: @@ -1595,7 +1595,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { continue; } - if (!check_using_stmt_entity(c, us, expr, is_selector, e)) { + if (!check_using_stmt_entity(ctx, us, expr, is_selector, e)) { return; } } @@ -1610,15 +1610,15 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Entity *e = nullptr; Operand o = {}; if (expr->kind == AstNode_Ident) { - e = check_ident(c, &o, expr, nullptr, nullptr, true); + e = check_ident(ctx, &o, expr, nullptr, nullptr, true); } else if (expr->kind == AstNode_SelectorExpr) { - e = check_selector(c, &o, expr, nullptr); + e = check_selector(ctx, &o, expr, nullptr); } if (e == nullptr) { error(expr, "'using' applied to an unknown entity"); return; } - add_entity_use(c, expr, e); + add_entity_use(ctx, expr, e); switch (e->kind) { @@ -1641,8 +1641,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { continue; } - add_entity_use(c, node, f); - add_entity(c, c->context.scope, node, f); + add_entity_use(ctx, node, f); + add_entity(ctx->checker, ctx->scope, node, f); } } else { error(node, "'using' can be only applied to enum type entities"); @@ -1670,8 +1670,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { bool implicit_is_found = ptr_set_exists(&scope->implicit, f); if (is_entity_exported(f) && !implicit_is_found) { - add_entity_use(c, node, f); - add_entity(c, c->context.scope, node, f); + add_entity_use(ctx, node, f); + add_entity(ctx->checker, ctx->scope, node, f); } else { error(node, "'%.*s' is exported from '%.*s'", LIT(f->token.string), LIT(e->token.string)); continue; @@ -1685,7 +1685,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Type *t = base_type(type_deref(e->type)); if (t->kind == Type_Struct) { // TODO(bill): Make it work for unions too - Scope *found = scope_of_node(&c->info, t->Struct.node); + Scope *found = scope_of_node(&ctx->checker->info, t->Struct.node); for_array(list_index, uis->list) { AstNode *node = uis->list[list_index]; ast_node(ident, Ident, node); @@ -1703,7 +1703,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Entity *uvar = alloc_entity_using_variable(e, f->token, f->type); uvar->using_expr = expr; - Entity *prev = scope_insert_entity(c->context.scope, uvar); + Entity *prev = scope_insert_entity(ctx->scope, uvar); if (prev != nullptr) { gbString expr_str = expr_to_string(expr); error(node, "Namespace collision while using '%s' of: '%.*s'", expr_str, LIT(prev->token.string)); @@ -1750,36 +1750,34 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_ast_node(pa, PushContext, node); Operand op = {}; - check_expr(c, &op, pa->expr); - check_assignment(c, &op, t_context, str_lit("argument to context <-")); - check_stmt(c, pa->body, mod_flags); + check_expr(ctx, &op, pa->expr); + check_assignment(ctx, &op, t_context, str_lit("argument to context <-")); + check_stmt(ctx, pa->body, mod_flags); case_end; case_ast_node(fb, ForeignBlockDecl, node); AstNode *foreign_library = fb->foreign_library; - CheckerContext prev_context = c->context; - defer (c->context = prev_context); - + CheckerContext c = *ctx; if (foreign_library->kind != AstNode_Ident) { error(foreign_library, "foreign library name must be an identifier"); } else { - c->context.foreign_context.curr_library = foreign_library; - c->context.foreign_context.default_cc = ProcCC_CDecl; + c.foreign_context.curr_library = foreign_library; + c.foreign_context.default_cc = ProcCC_CDecl; } - check_decl_attributes(c, fb->attributes, foreign_block_decl_attribute, nullptr); + check_decl_attributes(&c, fb->attributes, foreign_block_decl_attribute, nullptr); for_array(i, fb->decls) { AstNode *decl = fb->decls[i]; if (decl->kind == AstNode_ValueDecl && decl->ValueDecl.is_mutable) { - check_stmt(c, decl, flags); + check_stmt(&c, decl, flags); } } case_end; case_ast_node(vd, ValueDecl, node); if (vd->is_mutable) { - Entity **entities = gb_alloc_array(c->allocator, Entity *, vd->names.count); + Entity **entities = gb_alloc_array(ctx->allocator, Entity *, vd->names.count); isize entity_count = 0; isize new_name_count = 0; @@ -1794,14 +1792,14 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Entity *found = nullptr; // NOTE(bill): Ignore assignments to '_' if (!is_blank_ident(str)) { - found = current_scope_lookup_entity(c->context.scope, str); + found = current_scope_lookup_entity(ctx->scope, str); new_name_count += 1; } if (found == nullptr) { - entity = alloc_entity_variable(c->context.scope, token, nullptr, false); + entity = alloc_entity_variable(ctx->scope, token, nullptr, false); entity->identifier = name; - AstNode *fl = c->context.foreign_context.curr_library; + AstNode *fl = ctx->foreign_context.curr_library; if (fl != nullptr) { GB_ASSERT(fl->kind == AstNode_Ident); entity->Variable.is_foreign = true; @@ -1819,7 +1817,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (entity == nullptr) { entity = alloc_entity_dummy_variable(universal_scope, ast_node_token(name)); } - entity->parent_proc_decl = c->context.curr_proc_decl; + entity->parent_proc_decl = ctx->curr_proc_decl; entities[entity_count++] = entity; } @@ -1829,7 +1827,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Type *init_type = nullptr; if (vd->type != nullptr) { - init_type = check_type(c, vd->type); + init_type = check_type(ctx, vd->type); if (init_type == nullptr) { init_type = t_invalid; } else if (is_type_polymorphic(base_type(init_type))) { @@ -1847,8 +1845,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { // TODO NOTE(bill): This technically checks things multple times - AttributeContext ac = make_attribute_context(c->context.foreign_context.link_prefix); - check_decl_attributes(c, vd->attributes, var_decl_attribute, &ac); + AttributeContext ac = make_attribute_context(ctx->foreign_context.link_prefix); + check_decl_attributes(ctx, vd->attributes, var_decl_attribute, &ac); for (isize i = 0; i < entity_count; i++) { Entity *e = entities[i]; @@ -1864,7 +1862,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { e->type = init_type; e->state = EntityState_Resolved; } - ac.link_name = handle_link_name(c, e->token, ac.link_name, ac.link_prefix); + ac.link_name = handle_link_name(ctx, e->token, ac.link_name, ac.link_prefix); e->Variable.thread_local_model = ac.thread_local_model; if (ac.link_name.len > 0) { @@ -1872,8 +1870,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } } - check_arity_match(c, vd); - check_init_variables(c, entities, entity_count, vd->values, str_lit("variable declaration")); + check_arity_match(ctx, vd); + check_init_variables(ctx, entities, entity_count, vd->values, str_lit("variable declaration")); for (isize i = 0; i < entity_count; i++) { Entity *e = entities[i]; @@ -1890,9 +1888,9 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (vd->values.count > 0) { error(e->token, "A foreign variable declaration cannot have a default value"); } - init_entity_foreign_library(c, e); + init_entity_foreign_library(ctx, e); - auto *fp = &c->info.foreigns; + auto *fp = &ctx->checker->info.foreigns; HashKey key = hash_string(name); Entity **found = map_get(fp, key); if (found) { @@ -1910,7 +1908,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { map_set(fp, key, e); } } - add_entity(c, c->context.scope, e->identifier, e); + add_entity(ctx->checker, ctx->scope, e->identifier, e); } if (vd->is_using != 0) { @@ -1935,13 +1933,13 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (is_blank_ident(name)) { error(token, "'using' cannot be applied variable declared as '_'"); } else if (is_type_struct(t) || is_type_raw_union(t)) { - Scope *scope = scope_of_node(&c->info, t->Struct.node); + Scope *scope = scope_of_node(&ctx->checker->info, t->Struct.node); for_array(i, scope->elements.entries) { Entity *f = scope->elements.entries[i].value; if (f->kind == Entity_Variable) { Entity *uvar = alloc_entity_using_variable(e, f->token, f->type); uvar->Variable.is_immutable = is_immutable; - Entity *prev = scope_insert_entity(c->context.scope, uvar); + Entity *prev = scope_insert_entity(ctx->scope, uvar); if (prev != nullptr) { error(token, "Namespace collision while 'using' '%.*s' of: %.*s", LIT(name), LIT(prev->token.string)); return; diff --git a/src/check_type.cpp b/src/check_type.cpp index 3ccb30157..9e3a91a72 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -1,5 +1,5 @@ -void populate_using_entity_map(Checker *c, AstNode *node, Type *t, Map<Entity *> *entity_map) { +void populate_using_entity_map(CheckerContext *ctx, AstNode *node, Type *t, Map<Entity *> *entity_map) { t = base_type(type_deref(t)); gbString str = nullptr; defer (gb_string_free(str)); @@ -24,9 +24,9 @@ void populate_using_entity_map(Checker *c, AstNode *node, Type *t, Map<Entity *> } } else { map_set(entity_map, key, f); - add_entity(c, c->context.scope, nullptr, f); + add_entity(ctx->checker, ctx->scope, nullptr, f); if (f->flags & EntityFlag_Using) { - populate_using_entity_map(c, node, f->type, entity_map); + populate_using_entity_map(ctx, node, f->type, entity_map); } } } @@ -34,12 +34,12 @@ void populate_using_entity_map(Checker *c, AstNode *node, Type *t, Map<Entity *> } -void check_struct_fields(Checker *c, AstNode *node, Array<Entity *> *fields, Array<AstNode *> params, +void check_struct_fields(CheckerContext *ctx, AstNode *node, Array<Entity *> *fields, Array<AstNode *> params, isize init_field_capacity, Type *named_type, String context) { *fields = array_make<Entity *>(heap_allocator(), 0, init_field_capacity); Map<Entity *> entity_map = {}; - map_init(&entity_map, c->allocator, 2*init_field_capacity); + map_init(&entity_map, ctx->allocator, 2*init_field_capacity); defer (map_destroy(&entity_map)); @@ -67,7 +67,7 @@ void check_struct_fields(Checker *c, AstNode *node, Array<Entity *> *fields, Arr if (type_expr != nullptr) { - type = check_type_expr(c, type_expr, nullptr); + type = check_type_expr(ctx, type_expr, nullptr); if (is_type_polymorphic(type)) { type = nullptr; } @@ -95,8 +95,8 @@ void check_struct_fields(Checker *c, AstNode *node, Array<Entity *> *fields, Arr Token name_token = name->Ident.token; - Entity *field = alloc_entity_field(c->context.scope, name_token, type, is_using, field_src_index); - add_entity(c, c->context.scope, name, field); + Entity *field = alloc_entity_field(ctx->scope, name_token, type, is_using, field_src_index); + add_entity(ctx->checker, ctx->scope, name, field); array_add(fields, field); field_src_index += 1; @@ -117,23 +117,23 @@ void check_struct_fields(Checker *c, AstNode *node, Array<Entity *> *fields, Arr continue; } - populate_using_entity_map(c, node, type, &entity_map); + populate_using_entity_map(ctx, node, type, &entity_map); } } } -Entity *make_names_field_for_struct(Checker *c, Scope *scope) { +Entity *make_names_field_for_struct(CheckerContext *ctx, Scope *scope) { Entity *e = alloc_entity_field(scope, make_token_ident(str_lit("names")), t_string_slice, false, 0); e->Variable.is_immutable = true; e->flags |= EntityFlag_TypeField; return e; } -bool check_custom_align(Checker *c, AstNode *node, i64 *align_) { +bool check_custom_align(CheckerContext *ctx, AstNode *node, i64 *align_) { GB_ASSERT(align_ != nullptr); Operand o = {}; - check_expr(c, &o, node); + check_expr(ctx, &o, node); if (o.mode != Addressing_Constant) { if (o.mode != Addressing_Invalid) { error(node, "#align must be a constant"); @@ -165,11 +165,11 @@ bool check_custom_align(Checker *c, AstNode *node, i64 *align_) { } -Entity *find_polymorphic_struct_entity(Checker *c, Type *original_type, isize param_count, Array<Operand> ordered_operands) { - gb_mutex_lock(&c->mutex); - defer (gb_mutex_unlock(&c->mutex)); +Entity *find_polymorphic_struct_entity(CheckerContext *ctx, Type *original_type, isize param_count, Array<Operand> ordered_operands) { + gb_mutex_lock(&ctx->checker->mutex); + defer (gb_mutex_unlock(&ctx->checker->mutex)); - auto *found_gen_types = map_get(&c->info.gen_types, hash_pointer(original_type)); + auto *found_gen_types = map_get(&ctx->checker->info.gen_types, hash_pointer(original_type)); if (found_gen_types != nullptr) { for_array(i, *found_gen_types) { Entity *e = (*found_gen_types)[i]; @@ -208,10 +208,10 @@ Entity *find_polymorphic_struct_entity(Checker *c, Type *original_type, isize pa } -void add_polymorphic_struct_entity(Checker *c, AstNode *node, Type *named_type, Type *original_type) { +void add_polymorphic_struct_entity(CheckerContext *ctx, AstNode *node, Type *named_type, Type *original_type) { GB_ASSERT(is_type_named(named_type)); gbAllocator a = heap_allocator(); - Scope *s = c->context.scope->parent; + Scope *s = ctx->scope->parent; Entity *e = nullptr; { @@ -225,22 +225,23 @@ void add_polymorphic_struct_entity(Checker *c, AstNode *node, Type *named_type, e = alloc_entity_type_name(s, token, named_type); e->state = EntityState_Resolved; - add_entity_use(c, node, e); + e->pkg = ctx->pkg; + add_entity_use(ctx, node, e); } named_type->Named.type_name = e; - auto *found_gen_types = map_get(&c->info.gen_types, hash_pointer(original_type)); + auto *found_gen_types = map_get(&ctx->checker->info.gen_types, hash_pointer(original_type)); if (found_gen_types) { array_add(found_gen_types, e); } else { auto array = array_make<Entity *>(heap_allocator()); array_add(&array, e); - map_set(&c->info.gen_types, hash_pointer(original_type), array); + map_set(&ctx->checker->info.gen_types, hash_pointer(original_type), array); } } -void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Operand> *poly_operands, Type *named_type, Type *original_type_for_poly) { +void check_struct_type(CheckerContext *ctx, Type *struct_type, AstNode *node, Array<Operand> *poly_operands, Type *named_type, Type *original_type_for_poly) { GB_ASSERT(is_type_struct(struct_type)); ast_node(st, StructType, node); @@ -255,7 +256,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera case_end; } } - struct_type->Struct.names = make_names_field_for_struct(c, c->context.scope); + struct_type->Struct.names = make_names_field_for_struct(ctx, ctx->scope); if (st->is_raw_union) { struct_type->Struct.is_raw_union = true; @@ -280,7 +281,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera } } - auto entities = array_make<Entity *>(c->allocator, 0, variable_count); + auto entities = array_make<Entity *>(ctx->allocator, 0, variable_count); for_array(i, params) { AstNode *param = params[i]; @@ -305,7 +306,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera Type *specialization = nullptr; if (type_expr->TypeType.specialization != nullptr) { AstNode *s = type_expr->TypeType.specialization; - specialization = check_type(c, s); + specialization = check_type(ctx, s); // if (!is_type_polymorphic_struct(specialization)) { // gbString str = type_to_string(specialization); // defer (gb_string_free(str)); @@ -313,9 +314,9 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera // specialization = nullptr; // } } - type = alloc_type_generic(c->context.scope, 0, str_lit(""), specialization); + type = alloc_type_generic(ctx->scope, 0, str_lit(""), specialization); } else { - type = check_type(c, type_expr); + type = check_type(ctx, type_expr); if (is_type_polymorphic(type)) { is_type_polymorphic_type = true; } @@ -347,7 +348,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera gb_string_free(str); } - Scope *scope = c->context.scope; + Scope *scope = ctx->scope; for_array(j, p->names) { AstNode *name = p->names[j]; if (!ast_node_expect(name, AstNode_Ident)) { @@ -382,7 +383,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera } e->state = EntityState_Resolved; - add_entity(c, scope, name, e); + add_entity(ctx->checker, scope, name, e); array_add(&entities, e); } } @@ -396,7 +397,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera if (original_type_for_poly != nullptr) { GB_ASSERT(named_type != nullptr); - add_polymorphic_struct_entity(c, node, named_type, original_type_for_poly); + add_polymorphic_struct_entity(ctx, node, named_type, original_type_for_poly); } } @@ -414,7 +415,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera } } - struct_type->Struct.scope = c->context.scope; + struct_type->Struct.scope = ctx->scope; struct_type->Struct.is_packed = st->is_packed; struct_type->Struct.polymorphic_params = polymorphic_params; struct_type->Struct.is_polymorphic = is_polymorphic; @@ -422,7 +423,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera if (!is_polymorphic) { - check_struct_fields(c, node, &struct_type->Struct.fields, st->fields, min_field_count, named_type, context); + check_struct_fields(ctx, node, &struct_type->Struct.fields, st->fields, min_field_count, named_type, context); } if (st->align != nullptr) { @@ -431,12 +432,12 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera return; } i64 custom_align = 1; - if (check_custom_align(c, st->align, &custom_align)) { + if (check_custom_align(ctx, st->align, &custom_align)) { struct_type->Struct.custom_align = custom_align; } } } -void check_union_type(Checker *c, Type *union_type, AstNode *node) { +void check_union_type(CheckerContext *ctx, Type *union_type, AstNode *node) { GB_ASSERT(is_type_union(union_type)); ast_node(ut, UnionType, node); @@ -444,13 +445,13 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) { Entity *using_index_expr = nullptr; - auto variants = array_make<Type *>(c->allocator, 0, variant_count); + auto variants = array_make<Type *>(ctx->allocator, 0, variant_count); - union_type->Union.scope = c->context.scope; + union_type->Union.scope = ctx->scope; for_array(i, ut->variants) { AstNode *node = ut->variants[i]; - Type *t = check_type_expr(c, node, nullptr); + Type *t = check_type_expr(ctx, node, nullptr); if (t != nullptr && t != t_invalid) { bool ok = true; t = default_type(t); @@ -480,7 +481,7 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) { if (ut->align != nullptr) { i64 custom_align = 1; - if (check_custom_align(c, ut->align, &custom_align)) { + if (check_custom_align(ctx, ut->align, &custom_align)) { if (variants.count == 0) { error(ut->align, "An empty union cannot have a custom alignment"); } else { @@ -490,13 +491,13 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) { } } -void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *node) { +void check_enum_type(CheckerContext *ctx, Type *enum_type, Type *named_type, AstNode *node) { ast_node(et, EnumType, node); GB_ASSERT(is_type_enum(enum_type)); Type *base_type = t_int; if (et->base_type != nullptr) { - base_type = check_type(c, et->base_type); + base_type = check_type(ctx, et->base_type); } if (base_type == nullptr || !(is_type_integer(base_type) || is_type_float(base_type))) { @@ -510,13 +511,13 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod // NOTE(bill): Must be up here for the 'check_init_constant' system enum_type->Enum.base_type = base_type; - enum_type->Enum.scope = c->context.scope; + enum_type->Enum.scope = ctx->scope; Map<Entity *> entity_map = {}; // Key: String - map_init(&entity_map, c->allocator, 2*(et->fields.count)); + map_init(&entity_map, ctx->allocator, 2*(et->fields.count)); defer (map_destroy(&entity_map)); - auto fields = array_make<Entity *>(c->allocator, 0, et->fields.count); + auto fields = array_make<Entity *>(ctx->allocator, 0, et->fields.count); Type *constant_type = enum_type; if (named_type != nullptr) { @@ -549,13 +550,13 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod if (init != nullptr) { Operand o = {}; - check_expr(c, &o, init); + check_expr(ctx, &o, init); if (o.mode != Addressing_Constant) { error(init, "Enumeration value must be a constant"); o.mode = Addressing_Invalid; } if (o.mode != Addressing_Invalid) { - check_assignment(c, &o, constant_type, str_lit("enumeration")); + check_assignment(ctx, &o, constant_type, str_lit("enumeration")); } if (o.mode != Addressing_Invalid) { iota = o.value; @@ -594,7 +595,7 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod max_value = iota; } - Entity *e = alloc_entity_constant(c->context.scope, ident->Ident.token, constant_type, iota); + Entity *e = alloc_entity_constant(ctx->scope, ident->Ident.token, constant_type, iota); e->identifier = ident; e->flags |= EntityFlag_Visited; e->state = EntityState_Resolved; @@ -604,9 +605,9 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod error(ident, "'%.*s' is already declared in this enumeration", LIT(name)); } else { map_set(&entity_map, key, e); - add_entity(c, c->context.scope, nullptr, e); + add_entity(ctx->checker, ctx->scope, nullptr, e); array_add(&fields, e); - add_entity_use(c, field, e); + add_entity_use(ctx, field, e); } } GB_ASSERT(fields.count <= et->fields.count); @@ -615,7 +616,7 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod enum_type->Enum.fields = fields; enum_type->Enum.is_export = et->is_export; if (et->is_export) { - Scope *parent = c->context.scope->parent; + Scope *parent = ctx->scope->parent; for_array(i, fields) { Entity *f = fields[i]; if (f->kind != Entity_Constant) { @@ -625,30 +626,30 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod if (is_blank_ident(name)) { continue; } - add_entity(c, parent, nullptr, f); + add_entity(ctx->checker, parent, nullptr, f); } } - Scope *s = c->context.scope; + Scope *s = ctx->scope; enum_type->Enum.count = alloc_entity_constant(s, make_token_ident(str_lit("count")), t_int, exact_value_i64(fields.count)); enum_type->Enum.min_value = alloc_entity_constant(s, make_token_ident(str_lit("min_value")), constant_type, min_value); enum_type->Enum.max_value = alloc_entity_constant(s, make_token_ident(str_lit("max_value")), constant_type, max_value); - enum_type->Enum.names = make_names_field_for_struct(c, c->context.scope); + enum_type->Enum.names = make_names_field_for_struct(ctx, ctx->scope); } -void check_bit_field_type(Checker *c, Type *bit_field_type, AstNode *node) { +void check_bit_field_type(CheckerContext *ctx, Type *bit_field_type, AstNode *node) { ast_node(bft, BitFieldType, node); GB_ASSERT(is_type_bit_field(bit_field_type)); Map<Entity *> entity_map = {}; // Key: String - map_init(&entity_map, c->allocator, 2*(bft->fields.count)); + map_init(&entity_map, ctx->allocator, 2*(bft->fields.count)); defer (map_destroy(&entity_map)); - auto fields = array_make<Entity*>(c->allocator, 0, bft->fields.count); - auto sizes = array_make<u32> (c->allocator, 0, bft->fields.count); - auto offsets = array_make<u32> (c->allocator, 0, bft->fields.count); + auto fields = array_make<Entity*>(ctx->allocator, 0, bft->fields.count); + auto sizes = array_make<u32> (ctx->allocator, 0, bft->fields.count); + auto offsets = array_make<u32> (ctx->allocator, 0, bft->fields.count); u32 curr_offset = 0; for_array(i, bft->fields) { @@ -664,7 +665,7 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, AstNode *node) { String name = ident->Ident.token.string; Operand o = {}; - check_expr(c, &o, value); + check_expr(ctx, &o, value); if (o.mode != Addressing_Constant) { error(value, "Bit field bit size must be a constant"); continue; @@ -692,8 +693,8 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, AstNode *node) { error(ident, "'%.*s' is already declared in this bit field", LIT(name)); } else { map_set(&entity_map, key, e); - add_entity(c, c->context.scope, nullptr, e); - add_entity_use(c, field, e); + add_entity(ctx->checker, ctx->scope, nullptr, e); + add_entity_use(ctx, field, e); array_add(&fields, e); array_add(&offsets, curr_offset); @@ -710,14 +711,14 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, AstNode *node) { if (bft->align != nullptr) { i64 custom_align = 1; - if (check_custom_align(c, bft->align, &custom_align)) { + if (check_custom_align(ctx, bft->align, &custom_align)) { bit_field_type->BitField.custom_align = custom_align; } } } -bool check_type_specialization_to(Checker *c, Type *specialization, Type *type, bool compound, bool modify_type) { +bool check_type_specialization_to(CheckerContext *ctx, Type *specialization, Type *type, bool compound, bool modify_type) { if (type == nullptr || type == t_invalid) { return true; @@ -747,7 +748,7 @@ bool check_type_specialization_to(Checker *c, Type *specialization, Type *type, Entity *t_e = t_tuple->variables[i]; Type *st = s_e->type; Type *tt = t_e->type; - bool ok = is_polymorphic_type_assignable(c, st, tt, true, modify_type); + bool ok = is_polymorphic_type_assignable(ctx, st, tt, true, modify_type); } if (modify_type) { @@ -763,7 +764,7 @@ bool check_type_specialization_to(Checker *c, Type *specialization, Type *type, type->kind != Type_Named) { return false; } - if (is_polymorphic_type_assignable(c, base_type(specialization), base_type(type), compound, modify_type)) { + if (is_polymorphic_type_assignable(ctx, base_type(specialization), base_type(type), compound, modify_type)) { return true; } @@ -771,15 +772,15 @@ bool check_type_specialization_to(Checker *c, Type *specialization, Type *type, } -Type *determine_type_from_polymorphic(Checker *c, Type *poly_type, Operand operand) { - bool modify_type = !c->context.no_polymorphic_errors; +Type *determine_type_from_polymorphic(CheckerContext *ctx, Type *poly_type, Operand operand) { + bool modify_type = !ctx->no_polymorphic_errors; if (!is_operand_value(operand)) { if (modify_type) { error(operand.expr, "Cannot determine polymorphic type from parameter"); } return t_invalid; } - if (is_polymorphic_type_assignable(c, poly_type, operand.type, false, modify_type)) { + if (is_polymorphic_type_assignable(ctx, poly_type, operand.type, false, modify_type)) { return poly_type; } if (modify_type) { @@ -793,12 +794,12 @@ Type *determine_type_from_polymorphic(Checker *c, Type *poly_type, Operand opera } -Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_variadic_, isize *variadic_index_, bool *success_, isize *specialization_count_, Array<Operand> *operands) { +Type *check_get_params(CheckerContext *ctx, Scope *scope, AstNode *_params, bool *is_variadic_, isize *variadic_index_, bool *success_, isize *specialization_count_, Array<Operand> *operands) { if (_params == nullptr) { return nullptr; } - bool allow_polymorphic_types = c->context.allow_polymorphic_types; + bool allow_polymorphic_types = ctx->allow_polymorphic_types; bool success = true; ast_node(field_list, FieldList, _params); @@ -835,7 +836,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari bool is_variadic = false; isize variadic_index = -1; bool is_c_vararg = false; - auto variables = array_make<Entity *>(c->allocator, 0, variable_count); + auto variables = array_make<Entity *>(ctx->allocator, 0, variable_count); for_array(i, params) { AstNode *param = params[i]; if (param->kind != AstNode_Field) { @@ -858,12 +859,12 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (type_expr == nullptr) { if (default_value->kind == AstNode_BasicDirective && default_value->BasicDirective.name == "caller_location") { - init_preload(c); + init_preload(ctx->checker); default_is_location = true; type = t_source_code_location; } else { Operand o = {}; - check_expr_or_type(c, &o, default_value); + check_expr_or_type(ctx, &o, default_value); if (is_operand_nil(o)) { default_is_nil = true; } else if (o.mode != Addressing_Constant) { @@ -874,15 +875,15 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (o.mode == Addressing_Value && is_type_proc(o.type)) { Operand x = {}; if (default_value->kind == AstNode_Ident) { - e = check_ident(c, &x, default_value, nullptr, nullptr, false); + e = check_ident(ctx, &x, default_value, nullptr, nullptr, false); } else if (default_value->kind == AstNode_SelectorExpr) { - e = check_selector(c, &x, default_value, nullptr); + e = check_selector(ctx, &x, default_value, nullptr); } } if (e != nullptr && e->kind == Entity_Procedure) { value = exact_value_procedure(e->identifier); - add_entity_use(c, e->identifier, e); + add_entity_use(ctx, e->identifier, e); } else { error(default_value, "Default parameter must be a constant"); continue; @@ -916,7 +917,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (type_expr->kind == AstNode_TypeType) { ast_node(tt, TypeType, type_expr); is_type_param = true; - specialization = check_type(c, tt->specialization); + specialization = check_type(ctx, tt->specialization); if (specialization == t_invalid){ specialization = nullptr; } @@ -932,16 +933,16 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari detemine_type_from_operand = true; type = t_invalid; } else { - type = alloc_type_generic(c->context.scope, 0, str_lit(""), specialization); + type = alloc_type_generic(ctx->scope, 0, str_lit(""), specialization); } } else { - bool prev = c->context.allow_polymorphic_types; + bool prev = ctx->allow_polymorphic_types; if (operands != nullptr) { - c->context.allow_polymorphic_types = true; + ctx->allow_polymorphic_types = true; } - type = check_type(c, type_expr); + type = check_type(ctx, type_expr); - c->context.allow_polymorphic_types = prev; + ctx->allow_polymorphic_types = prev; if (is_type_polymorphic(type)) { is_type_polymorphic_type = true; @@ -956,12 +957,12 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari Operand o = {}; if (default_value->kind == AstNode_BasicDirective && default_value->BasicDirective.name == "caller_location") { - init_preload(c); + init_preload(ctx->checker); default_is_location = true; o.type = t_source_code_location; o.mode = Addressing_Value; } else { - check_expr_with_type_hint(c, &o, default_value, type); + check_expr_with_type_hint(ctx, &o, default_value, type); if (is_operand_nil(o)) { default_is_nil = true; @@ -973,15 +974,15 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (o.mode == Addressing_Value && is_type_proc(o.type)) { Operand x = {}; if (default_value->kind == AstNode_Ident) { - e = check_ident(c, &x, default_value, nullptr, nullptr, false); + e = check_ident(ctx, &x, default_value, nullptr, nullptr, false); } else if (default_value->kind == AstNode_SelectorExpr) { - e = check_selector(c, &x, default_value, nullptr); + e = check_selector(ctx, &x, default_value, nullptr); } } if (e != nullptr && e->kind == Entity_Procedure) { value = exact_value_procedure(e->identifier); - add_entity_use(c, e->identifier, e); + add_entity_use(ctx, e->identifier, e); } else { error(default_value, "Default parameter must be a constant"); } @@ -991,7 +992,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari } } - check_is_assignable_to(c, &o, type); + check_is_assignable_to(ctx, &o, type); } } } @@ -1050,7 +1051,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (o.mode == Addressing_Type) { type = o.type; } else { - if (!c->context.no_polymorphic_errors) { + if (!ctx->no_polymorphic_errors) { error(o.expr, "Expected a type to assign to the type parameter"); } success = false; @@ -1063,10 +1064,10 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari success = false; type = t_invalid; } - bool modify_type = !c->context.no_polymorphic_errors; + bool modify_type = !ctx->no_polymorphic_errors; - if (specialization != nullptr && !check_type_specialization_to(c, specialization, type, false, modify_type)) { - if (!c->context.no_polymorphic_errors) { + if (specialization != nullptr && !check_type_specialization_to(ctx, specialization, type, false, modify_type)) { + if (!ctx->no_polymorphic_errors) { gbString t = type_to_string(type); gbString s = type_to_string(specialization); error(o.expr, "Cannot convert type '%s' to the specialization '%s'", t, s); @@ -1083,10 +1084,10 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (operands != nullptr && variables.count < operands->count) { if (is_type_polymorphic_type) { Operand op = (*operands)[variables.count]; - type = determine_type_from_polymorphic(c, type, op); + type = determine_type_from_polymorphic(ctx, type, op); if (type == t_invalid) { success = false; - } else if (!c->context.no_polymorphic_errors) { + } else if (!ctx->no_polymorphic_errors) { // NOTE(bill): The type should be determined now and thus, no need to determine the type any more is_type_polymorphic_type = false; } @@ -1110,7 +1111,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari } param->state = EntityState_Resolved; // NOTE(bill): This should have be resolved whilst determining it - add_entity(c, scope, name, param); + add_entity(ctx->checker, scope, name, param); array_add(&variables, param); } } @@ -1157,7 +1158,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari return tuple; } -Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { +Type *check_get_results(CheckerContext *ctx, Scope *scope, AstNode *_results) { if (_results == nullptr) { return nullptr; } @@ -1178,7 +1179,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { } } - auto variables = array_make<Entity *>(c->allocator, 0, variable_count); + auto variables = array_make<Entity *>(ctx->allocator, 0, variable_count); for_array(i, results) { ast_node(field, Field, results[i]); AstNode *default_value = unparen_expr(field->default_value); @@ -1188,7 +1189,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { Type *type = nullptr; if (field->type == nullptr) { Operand o = {}; - check_expr(c, &o, default_value); + check_expr(ctx, &o, default_value); if (is_operand_nil(o)) { default_is_nil = true; } else if (o.mode != Addressing_Constant) { @@ -1199,11 +1200,11 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { type = default_type(o.type); } else { - type = check_type(c, field->type); + type = check_type(ctx, field->type); if (default_value != nullptr) { Operand o = {}; - check_expr_with_type_hint(c, &o, default_value, type); + check_expr_with_type_hint(ctx, &o, default_value, type); if (is_operand_nil(o)) { default_is_nil = true; @@ -1212,7 +1213,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { } else { value = o.value; } - check_is_assignable_to(c, &o, type); + check_is_assignable_to(ctx, &o, type); } } @@ -1257,7 +1258,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { param->Variable.default_value = value; param->Variable.default_is_nil = default_is_nil; array_add(&variables, param); - add_entity(c, scope, name, param); + add_entity(ctx->checker, scope, name, param); } } } @@ -1473,23 +1474,24 @@ bool abi_compat_return_by_value(gbAllocator a, ProcCallingConvention cc, Type *a } // NOTE(bill): 'operands' is for generating non generic procedure type -bool check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node, Array<Operand> *operands) { +bool check_procedure_type(CheckerContext *ctx, Type *type, AstNode *proc_type_node, Array<Operand> *operands) { ast_node(pt, ProcType, proc_type_node); - if (c->context.polymorphic_scope == nullptr && c->context.allow_polymorphic_types) { - c->context.polymorphic_scope = c->context.scope; + if (ctx->polymorphic_scope == nullptr && ctx->allow_polymorphic_types) { + ctx->polymorphic_scope = ctx->scope; } - CheckerContext prev = c->context; - defer (c->context = prev); - c->context.curr_proc_sig = type; + CheckerContext c_ = *ctx; + CheckerContext *c = &c_; + + c->curr_proc_sig = type; bool variadic = false; isize variadic_index = -1; bool success = true; isize specialization_count = 0; - Type *params = check_get_params(c, c->context.scope, pt->params, &variadic, &variadic_index, &success, &specialization_count, operands); - Type *results = check_get_results(c, c->context.scope, pt->results); + Type *params = check_get_params(c, c->scope, pt->params, &variadic, &variadic_index, &success, &specialization_count, operands); + Type *results = check_get_results(c, c->scope, pt->results); isize param_count = 0; @@ -1516,14 +1518,14 @@ bool check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node, Array ProcCallingConvention cc = pt->calling_convention; if (cc == ProcCC_ForeignBlockDefault) { cc = ProcCC_CDecl; - if (c->context.foreign_context.default_cc > 0) { - cc = c->context.foreign_context.default_cc; + if (c->foreign_context.default_cc > 0) { + cc = c->foreign_context.default_cc; } } GB_ASSERT(cc > 0); type->Proc.node = proc_type_node; - type->Proc.scope = c->context.scope; + type->Proc.scope = c->scope; type->Proc.params = params; type->Proc.param_count = cast(i32)param_count; type->Proc.results = results; @@ -1578,7 +1580,7 @@ bool check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node, Array } -i64 check_array_count(Checker *c, Operand *o, AstNode *e) { +i64 check_array_count(CheckerContext *ctx, Operand *o, AstNode *e) { if (e == nullptr) { return 0; } @@ -1587,9 +1589,9 @@ i64 check_array_count(Checker *c, Operand *o, AstNode *e) { return -1; } - check_expr_or_type(c, o, e); + check_expr_or_type(ctx, o, e); if (o->mode == Addressing_Type && o->type->kind == Type_Generic) { - if (c->context.allow_polymorphic_types) { + if (ctx->allow_polymorphic_types) { if (o->type->Generic.specialized) { o->type->Generic.specialized = nullptr; error(o->expr, "Polymorphic array length cannot have a specialization"); @@ -1703,12 +1705,12 @@ void init_map_internal_types(Type *type) { type->Map.lookup_result_type = make_optional_ok_type(value); } -void check_map_type(Checker *c, Type *type, AstNode *node) { +void check_map_type(CheckerContext *ctx, Type *type, AstNode *node) { GB_ASSERT(type->kind == Type_Map); ast_node(mt, MapType, node); - Type *key = check_type(c, mt->key); - Type *value = check_type(c, mt->value); + Type *key = check_type(ctx, mt->key); + Type *value = check_type(ctx, mt->value); if (!is_type_valid_for_keys(key)) { if (is_type_boolean(key)) { @@ -1724,11 +1726,11 @@ void check_map_type(Checker *c, Type *type, AstNode *node) { type->Map.value = value; if (is_type_string(key)) { - add_package_dependency(c, "runtime", "__default_hash_string"); + add_package_dependency(ctx, "runtime", "__default_hash_string"); } - init_preload(c); + init_preload(ctx->checker); init_map_internal_types(type); // error(node, "'map' types are not yet implemented"); @@ -1736,7 +1738,7 @@ void check_map_type(Checker *c, Type *type, AstNode *node) { -bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) { +bool check_type_internal(CheckerContext *ctx, AstNode *e, Type **type, Type *named_type) { GB_ASSERT_NOT_NULL(type); if (e == nullptr) { *type = t_invalid; @@ -1746,7 +1748,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) switch (e->kind) { case_ast_node(i, Ident, e); Operand o = {}; - Entity *entity = check_ident(c, &o, e, named_type, nullptr, false); + Entity *entity = check_ident(ctx, &o, e, named_type, nullptr, false); gbString err_str = nullptr; defer (gb_string_free(err_str)); @@ -1756,7 +1758,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) break; case Addressing_Type: { *type = o.type; - if (!c->context.in_polymorphic_specialization) { + if (!ctx->in_polymorphic_specialization) { Type *t = base_type(o.type); if (t != nullptr && is_type_polymorphic_struct_unspecialized(t)) { err_str = expr_to_string(e); @@ -1765,10 +1767,10 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) } } - // if (c->context.type_level == 0 && entity->state == EntityState_InProgress) { + // if (ctx->type_level == 0 && entity->state == EntityState_InProgress) { // error(entity->token, "Illegal declaration cycle of `%.*s`", LIT(entity->token.string)); - // for_array(j, *c->context.type_path) { - // Entity *k = (*c->context.type_path)[j]; + // for_array(j, *ctx->type_path) { + // Entity *k = (*ctx->type_path)[j]; // error(k->token, "\t%.*s refers to", LIT(k->token.string)); // } // error(entity->token, "\t%.*s", LIT(entity->token.string)); @@ -1790,13 +1792,13 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case_end; case_ast_node(ht, HelperType, e); - return check_type_internal(c, ht->type, type, named_type); + return check_type_internal(ctx, ht->type, type, named_type); case_end; case_ast_node(dt, DistinctType, e); error(e, "Invalid use of a distinct type"); // NOTE(bill): Treat it as a HelperType to remove errors - return check_type_internal(c, dt->type, type, named_type); + return check_type_internal(ctx, dt->type, type, named_type); case_end; case_ast_node(pt, PolyType, e); @@ -1810,22 +1812,16 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) Token token = ident->Ident.token; Type *specific = nullptr; if (pt->specialization != nullptr) { - CheckerContext prev = c->context; defer (c->context = prev); - c->context.in_polymorphic_specialization = true; + CheckerContext c = *ctx; + c.in_polymorphic_specialization = true; AstNode *s = pt->specialization; - specific = check_type(c, s); - // if (!is_type_polymorphic_struct(specific)) { - // gbString str = type_to_string(specific); - // error(s, "Expected a polymorphic struct, got %s", str); - // gb_string_free(str); - // specific = nullptr; - // } + specific = check_type(&c, s); } - Type *t = alloc_type_generic(c->context.scope, 0, token.string, specific); - if (c->context.allow_polymorphic_types) { - Scope *ps = c->context.polymorphic_scope; - Scope *s = c->context.scope; + Type *t = alloc_type_generic(ctx->scope, 0, token.string, specific); + if (ctx->allow_polymorphic_types) { + Scope *ps = ctx->polymorphic_scope; + Scope *s = ctx->scope; Scope *entity_scope = s; if (ps != nullptr && ps != s) { // TODO(bill): Is this check needed? @@ -1835,8 +1831,8 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) Entity *e = alloc_entity_type_name(entity_scope, token, t); e->TypeName.is_type_alias = true; e->state = EntityState_Resolved; - add_entity(c, ps, ident, e); - add_entity(c, s, ident, e); + add_entity(ctx->checker, ps, ident, e); + add_entity(ctx->checker, s, ident, e); } else { error(ident, "Invalid use of a polymorphic parameter '$%.*s'", LIT(token.string)); *type = t_invalid; @@ -1849,7 +1845,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case_ast_node(se, SelectorExpr, e); Operand o = {}; - check_selector(c, &o, e, nullptr); + check_selector(ctx, &o, e, nullptr); gbString err_str; switch (o.mode) { @@ -1873,7 +1869,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case_end; case_ast_node(pe, ParenExpr, e); - *type = check_type_expr(c, pe->expr, named_type); + *type = check_type_expr(ctx, pe->expr, named_type); set_base_type(named_type, *type); return true; case_end; @@ -1881,14 +1877,14 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case_ast_node(ue, UnaryExpr, e); switch (ue->op.kind) { case Token_Pointer: - *type = alloc_type_pointer(check_type(c, ue->expr)); + *type = alloc_type_pointer(check_type(ctx, ue->expr)); set_base_type(named_type, *type); return true; } case_end; case_ast_node(pt, PointerType, e); - *type = alloc_type_pointer(check_type(c, pt->type)); + *type = alloc_type_pointer(check_type(ctx, pt->type)); set_base_type(named_type, *type); return true; case_end; @@ -1896,7 +1892,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case_ast_node(at, ArrayType, e); if (at->count != nullptr) { Operand o = {}; - i64 count = check_array_count(c, &o, at->count); + i64 count = check_array_count(ctx, &o, at->count); Type *generic_type = nullptr; if (o.mode == Addressing_Type && o.type->kind == Type_Generic) { generic_type = o.type; @@ -1905,10 +1901,10 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) error(at->count, "... can only be used in conjuction with compound literals"); count = 0; } - Type *elem = check_type_expr(c, at->elem, nullptr); + Type *elem = check_type_expr(ctx, at->elem, nullptr); *type = alloc_type_array(elem, count, generic_type); } else { - Type *elem = check_type(c, at->elem); + Type *elem = check_type(ctx, at->elem); *type = alloc_type_slice(elem); } set_base_type(named_type, *type); @@ -1916,50 +1912,50 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case_end; case_ast_node(dat, DynamicArrayType, e); - Type *elem = check_type(c, dat->elem); + Type *elem = check_type(ctx, dat->elem); *type = alloc_type_dynamic_array(elem); set_base_type(named_type, *type); return true; case_end; case_ast_node(st, StructType, e); - CheckerContext prev = c->context; defer (c->context = prev); - c->context.in_polymorphic_specialization = false; - c->context.type_level += 1; + CheckerContext c = *ctx; + c.in_polymorphic_specialization = false; + c.type_level += 1; *type = alloc_type_struct(); set_base_type(named_type, *type); - check_open_scope(c, e); - check_struct_type(c, *type, e, nullptr, named_type); - check_close_scope(c); + check_open_scope(&c, e); + check_struct_type(&c, *type, e, nullptr, named_type); + check_close_scope(&c); (*type)->Struct.node = e; return true; case_end; case_ast_node(ut, UnionType, e); - CheckerContext prev = c->context; defer (c->context = prev); - c->context.in_polymorphic_specialization = false; - c->context.type_level += 1; + CheckerContext c = *ctx; + c.in_polymorphic_specialization = false; + c.type_level += 1; *type = alloc_type_union(); set_base_type(named_type, *type); - check_open_scope(c, e); - check_union_type(c, *type, e); - check_close_scope(c); + check_open_scope(&c, e); + check_union_type(&c, *type, e); + check_close_scope(&c); (*type)->Union.node = e; return true; case_end; case_ast_node(et, EnumType, e); - bool ips = c->context.in_polymorphic_specialization; - defer (c->context.in_polymorphic_specialization = ips); - c->context.in_polymorphic_specialization = false; + bool ips = ctx->in_polymorphic_specialization; + defer (ctx->in_polymorphic_specialization = ips); + ctx->in_polymorphic_specialization = false; *type = alloc_type_enum(); set_base_type(named_type, *type); - check_open_scope(c, e); - check_enum_type(c, *type, named_type, e); - check_close_scope(c); + check_open_scope(ctx, e); + check_enum_type(ctx, *type, named_type, e); + check_close_scope(ctx); (*type)->Enum.node = e; return true; case_end; @@ -1967,39 +1963,39 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case_ast_node(et, BitFieldType, e); *type = alloc_type_bit_field(); set_base_type(named_type, *type); - check_open_scope(c, e); - check_bit_field_type(c, *type, e); - check_close_scope(c); + check_open_scope(ctx, e); + check_bit_field_type(ctx, *type, e); + check_close_scope(ctx); return true; case_end; case_ast_node(pt, ProcType, e); - bool ips = c->context.in_polymorphic_specialization; - defer (c->context.in_polymorphic_specialization = ips); - c->context.in_polymorphic_specialization = false; + bool ips = ctx->in_polymorphic_specialization; + defer (ctx->in_polymorphic_specialization = ips); + ctx->in_polymorphic_specialization = false; *type = alloc_type(Type_Proc); set_base_type(named_type, *type); - check_open_scope(c, e); - check_procedure_type(c, *type, e); - check_close_scope(c); + check_open_scope(ctx, e); + check_procedure_type(ctx, *type, e); + check_close_scope(ctx); return true; case_end; case_ast_node(mt, MapType, e); - bool ips = c->context.in_polymorphic_specialization; - defer (c->context.in_polymorphic_specialization = ips); - c->context.in_polymorphic_specialization = false; + bool ips = ctx->in_polymorphic_specialization; + defer (ctx->in_polymorphic_specialization = ips); + ctx->in_polymorphic_specialization = false; *type = alloc_type(Type_Map); set_base_type(named_type, *type); - check_map_type(c, *type, e); + check_map_type(ctx, *type, e); return true; case_end; case_ast_node(ce, CallExpr, e); Operand o = {}; - check_expr_or_type(c, &o, e); + check_expr_or_type(ctx, &o, e); if (o.mode == Addressing_Type) { *type = o.type; set_base_type(named_type, *type); @@ -2009,7 +2005,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case_ast_node(te, TernaryExpr, e); Operand o = {}; - check_expr_or_type(c, &o, e); + check_expr_or_type(ctx, &o, e); if (o.mode == Addressing_Type) { *type = o.type; set_base_type(named_type, *type); @@ -2022,17 +2018,17 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) return false; } -Type *check_type(Checker *c, AstNode *e) { - auto prev_context = c->context; defer (c->context = prev_context); - c->context.type_path = new_checker_type_path(); - defer (destroy_checker_type_path(c->context.type_path)); +Type *check_type(CheckerContext *ctx, AstNode *e) { + CheckerContext c = *ctx; + c.type_path = new_checker_type_path(); + defer (destroy_checker_type_path(c.type_path)); - return check_type_expr(c, e, nullptr); + return check_type_expr(&c, e, nullptr); } -Type *check_type_expr(Checker *c, AstNode *e, Type *named_type) { +Type *check_type_expr(CheckerContext *ctx, AstNode *e, Type *named_type) { Type *type = nullptr; - bool ok = check_type_internal(c, e, &type, named_type); + bool ok = check_type_internal(ctx, e, &type, named_type); if (!ok) { gbString err_str = expr_to_string(e); @@ -2055,7 +2051,7 @@ Type *check_type_expr(Checker *c, AstNode *e, Type *named_type) { } #if 0 - if (!c->context.allow_polymorphic_types && is_type_polymorphic(type)) { + if (!ctx->allow_polymorphic_types && is_type_polymorphic(type)) { gbString str = type_to_string(type); error(e, "Invalid use of a polymorphic type '%s'", str); gb_string_free(str); @@ -2064,7 +2060,7 @@ Type *check_type_expr(Checker *c, AstNode *e, Type *named_type) { #endif if (is_type_typed(type)) { - add_type_and_value(&c->info, e, Addressing_Type, type, empty_exact_value); + add_type_and_value(&ctx->checker->info, e, Addressing_Type, type, empty_exact_value); } else { gbString name = type_to_string(type); error(e, "Invalid type definition of %s", name); diff --git a/src/checker.cpp b/src/checker.cpp index d6b564027..7791420e4 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -1,7 +1,7 @@ #include "entity.cpp" #include "types.cpp" -void check_expr(Checker *c, Operand *operand, AstNode *expression); +void check_expr(CheckerContext *c, Operand *operand, AstNode *expression); bool is_operand_value(Operand o) { @@ -229,7 +229,7 @@ Scope *create_scope(Scope *parent, gbAllocator allocator, isize init_elements_ca return s; } -Scope *create_scope_from_file(Checker *c, AstFile *f) { +Scope *create_scope_from_file(CheckerContext *c, AstFile *f) { GB_ASSERT(f != nullptr); GB_ASSERT(f->pkg != nullptr); GB_ASSERT(f->pkg->scope != nullptr); @@ -246,7 +246,7 @@ Scope *create_scope_from_file(Checker *c, AstFile *f) { return s; } -Scope *create_scope_from_package(Checker *c, AstPackage *p) { +Scope *create_scope_from_package(CheckerContext *c, AstPackage *p) { GB_ASSERT(p != nullptr); isize decl_count = 0; @@ -254,14 +254,13 @@ Scope *create_scope_from_package(Checker *c, AstPackage *p) { decl_count += p->files[i]->decls.count; } isize init_elements_capacity = 2*decl_count; - Scope *s = create_scope(universal_scope, c->allocator, init_elements_capacity); s->is_package = true; s->package = p; p->scope = s; - if (p->fullpath == c->parser->init_fullpath) { + if (p->fullpath == c->checker->parser->init_fullpath) { s->is_init = true; } else { s->is_init = p->kind == Package_Init; @@ -306,7 +305,7 @@ void destroy_scope(Scope *scope) { } -void add_scope(Checker *c, AstNode *node, Scope *scope) { +void add_scope(CheckerContext *c, AstNode *node, Scope *scope) { GB_ASSERT(node != nullptr); GB_ASSERT(scope != nullptr); scope->node = node; @@ -314,12 +313,12 @@ void add_scope(Checker *c, AstNode *node, Scope *scope) { } -void check_open_scope(Checker *c, AstNode *node) { +void check_open_scope(CheckerContext *c, AstNode *node) { node = unparen_expr(node); GB_ASSERT(node->kind == AstNode_Invalid || is_ast_node_stmt(node) || is_ast_node_type(node)); - Scope *scope = create_scope(c->context.scope, c->allocator); + Scope *scope = create_scope(c->scope, c->allocator); add_scope(c, node, scope); switch (node->kind) { case AstNode_ProcType: @@ -331,12 +330,12 @@ void check_open_scope(Checker *c, AstNode *node) { scope->is_struct = true; break; } - c->context.scope = scope; - c->context.stmt_state_flags |= StmtStateFlag_bounds_check; + c->scope = scope; + c->stmt_state_flags |= StmtStateFlag_bounds_check; } -void check_close_scope(Checker *c) { - c->context.scope = c->context.scope->parent; +void check_close_scope(CheckerContext *c) { + c->scope = c->scope->parent; } @@ -488,7 +487,7 @@ void add_dependency(DeclInfo *d, Entity *e) { } void add_type_info_dependency(DeclInfo *d, Type *type) { if (d == nullptr) { - GB_ASSERT(type == t_invalid); + // GB_ASSERT(type == t_invalid); return; } ptr_set_add(&d->type_info_deps, type); @@ -505,22 +504,22 @@ AstPackage *get_core_package(CheckerInfo *info, String name) { } -void add_package_dependency(Checker *c, char *package_name, char *name) { +void add_package_dependency(CheckerContext *c, char *package_name, char *name) { String n = make_string_c(name); - AstPackage *p = get_core_package(&c->info, make_string_c(package_name)); + AstPackage *p = get_core_package(&c->checker->info, make_string_c(package_name)); Entity *e = scope_lookup_entity(p->scope, n); GB_ASSERT(e != nullptr); - ptr_set_add(&c->context.decl->deps, e); + ptr_set_add(&c->decl->deps, e); // add_type_info_type(c, e->type); } -void add_declaration_dependency(Checker *c, Entity *e) { +void add_declaration_dependency(CheckerContext *c, Entity *e) { if (e == nullptr) { return; } - if (c->context.decl != nullptr) { + if (c->decl != nullptr) { // DeclInfo *decl = decl_info_of_entity(&c->info, e); - add_dependency(c->context.decl, e); + add_dependency(c->decl, e); } } @@ -641,6 +640,20 @@ void destroy_checker_info(CheckerInfo *i) { array_free(&i->variable_init_order); } +CheckerContext make_checker_context(Checker *c) { + CheckerContext ctx = c->init_ctx; + ctx.checker = c; + ctx.allocator = c->allocator; + ctx.scope = universal_scope; + + ctx.type_path = new_checker_type_path(); + ctx.type_level = 0; + return ctx; +} + +void destroy_checker_context(CheckerContext *ctx) { + destroy_checker_type_path(ctx->type_path); +} void init_checker(Checker *c, Parser *parser) { if (global_error_collector.count > 0) { @@ -658,10 +671,8 @@ void init_checker(Checker *c, Parser *parser) { isize item_size = gb_max3(gb_size_of(Entity), gb_size_of(Type), gb_size_of(Scope)); isize total_token_count = c->parser->total_token_count; isize arena_size = 2 * item_size * total_token_count; - // gb_arena_init_from_allocator(&c->tmp_arena, a, arena_size); c->allocator = heap_allocator(); - // c->tmp_allocator = gb_arena_allocator(&c->tmp_arena); isize pkg_cap = 2*c->parser->packages.count; @@ -669,12 +680,7 @@ void init_checker(Checker *c, Parser *parser) { array_init(&c->package_order, heap_allocator(), 0, c->parser->packages.count); - // Init context - c->context.checker = c; - c->context.scope = universal_scope; - - c->context.type_path = new_checker_type_path(); - c->context.type_level = 0; + c->init_ctx = make_checker_context(c); } void destroy_checker(Checker *c) { @@ -688,7 +694,7 @@ void destroy_checker(Checker *c) { map_destroy(&c->package_scopes); array_free(&c->package_order); - destroy_checker_type_path(c->context.type_path); + destroy_checker_context(&c->init_ctx); } @@ -913,7 +919,7 @@ bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) { return true; } -void add_entity_use(Checker *c, AstNode *identifier, Entity *entity) { +void add_entity_use(CheckerContext *c, AstNode *identifier, Entity *entity) { if (entity == nullptr) { return; } @@ -936,7 +942,7 @@ void add_entity_use(Checker *c, AstNode *identifier, Entity *entity) { } -void add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclInfo *d) { +void add_entity_and_decl_info(CheckerContext *c, AstNode *identifier, Entity *e, DeclInfo *d) { GB_ASSERT(identifier->kind == AstNode_Ident); GB_ASSERT(e != nullptr && d != nullptr); GB_ASSERT(identifier->Ident.token.string == e->token.string); @@ -952,25 +958,25 @@ void add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclIn default: { AstPackage *pkg = scope->file->pkg; GB_ASSERT(pkg->scope == scope->parent); - GB_ASSERT(c->context.pkg == pkg); + GB_ASSERT(c->pkg == pkg); scope = pkg->scope; break; } } } - add_entity(c, scope, identifier, e); + add_entity(c->checker, scope, identifier, e); } - add_entity_definition(&c->info, identifier, e); + add_entity_definition(&c->checker->info, identifier, e); GB_ASSERT(e->decl_info == nullptr); e->decl_info = d; - array_add(&c->info.entities, e); - e->order_in_src = c->info.entities.count; - e->pkg = c->context.pkg; + array_add(&c->checker->info.entities, e); + e->order_in_src = c->checker->info.entities.count; + e->pkg = c->pkg; } -void add_implicit_entity(Checker *c, AstNode *clause, Entity *e) { +void add_implicit_entity(CheckerContext *c, AstNode *clause, Entity *e) { GB_ASSERT(clause != nullptr); GB_ASSERT(e != nullptr); GB_ASSERT(clause->kind == AstNode_CaseClause); @@ -981,7 +987,7 @@ void add_implicit_entity(Checker *c, AstNode *clause, Entity *e) { -void add_type_info_type(Checker *c, Type *t) { +void add_type_info_type(CheckerContext *c, Type *t) { if (t == nullptr) { return; } @@ -996,17 +1002,17 @@ void add_type_info_type(Checker *c, Type *t) { return; } - auto found = map_get(&c->info.type_info_map, hash_type(t)); + auto found = map_get(&c->checker->info.type_info_map, hash_type(t)); if (found != nullptr) { // Types have already been added - add_type_info_dependency(c->context.decl, t); + add_type_info_dependency(c->decl, t); return; } bool prev = false; isize ti_index = -1; - for_array(i, c->info.type_info_map.entries) { - auto *e = &c->info.type_info_map.entries[i]; + for_array(i, c->checker->info.type_info_map.entries) { + auto *e = &c->checker->info.type_info_map.entries[i]; Type *prev_type = cast(Type *)e->key.ptr; if (are_types_identical(t, prev_type)) { // Duplicate entry @@ -1018,14 +1024,14 @@ void add_type_info_type(Checker *c, Type *t) { if (ti_index < 0) { // Unique entry // NOTE(bill): map entries grow linearly and in order - ti_index = c->info.type_info_types.count; - array_add(&c->info.type_info_types, t); + ti_index = c->checker->info.type_info_types.count; + array_add(&c->checker->info.type_info_types, t); } - map_set(&c->info.type_info_map, hash_type(t), ti_index); + map_set(&c->checker->info.type_info_map, hash_type(t), ti_index); if (prev) { // NOTE(bill): If a previous one exists already, no need to continue - add_type_info_dependency(c->context.decl, t); + add_type_info_dependency(c->decl, t); return; } @@ -1148,14 +1154,14 @@ void check_procedure_later(Checker *c, AstFile *file, Token token, DeclInfo *dec check_procedure_later(c, info); } -void add_curr_ast_file(Checker *c, AstFile *file) { +void add_curr_ast_file(CheckerContext *ctx, AstFile *file) { if (file != nullptr) { TokenPos zero_pos = {}; global_error_collector.prev = zero_pos; - c->context.file = file; - c->context.decl = file->pkg->decl_info; - c->context.scope = file->scope; - c->context.pkg = file->pkg; + ctx->file = file; + ctx->decl = file->pkg->decl_info; + ctx->scope = file->scope; + ctx->pkg = file->pkg; } } @@ -1530,22 +1536,22 @@ void destroy_checker_type_path(CheckerTypePath *tp) { } -void check_type_path_push(Checker *c, Entity *e) { - GB_ASSERT(c->context.type_path != nullptr); +void check_type_path_push(CheckerContext *c, Entity *e) { + GB_ASSERT(c->type_path != nullptr); GB_ASSERT(e != nullptr); - array_add(c->context.type_path, e); + array_add(c->type_path, e); } -Entity *check_type_path_pop(Checker *c) { - GB_ASSERT(c->context.type_path != nullptr); - return array_pop(c->context.type_path); +Entity *check_type_path_pop(CheckerContext *c) { + GB_ASSERT(c->type_path != nullptr); + return array_pop(c->type_path); } -void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type); +void check_entity_decl(CheckerContext *c, Entity *e, DeclInfo *d, Type *named_type); -Array<Entity *> proc_group_entities(Checker *c, Operand o) { +Array<Entity *> proc_group_entities(CheckerContext *c, Operand o) { Array<Entity *> procs = {}; if (o.mode == Addressing_ProcGroup) { GB_ASSERT(o.proc_group != nullptr); @@ -1681,7 +1687,7 @@ DECL_ATTRIBUTE_PROC(foreign_block_decl_attribute) { if (cc == ProcCC_Invalid) { error(elem, "Unknown procedure calling convention: '%.*s'\n", LIT(value.value_string)); } else { - c->context.foreign_context.default_cc = cc; + c->foreign_context.default_cc = cc; } } else { error(elem, "Expected a string value for '%.*s'", LIT(name)); @@ -1693,7 +1699,7 @@ DECL_ATTRIBUTE_PROC(foreign_block_decl_attribute) { if (!is_foreign_name_valid(link_prefix)) { error(elem, "Invalid link prefix: '%.*s'\n", LIT(link_prefix)); } else { - c->context.foreign_context.link_prefix = link_prefix; + c->foreign_context.link_prefix = link_prefix; } } else { error(elem, "Expected a string value for '%.*s'", LIT(name)); @@ -1742,7 +1748,7 @@ DECL_ATTRIBUTE_PROC(proc_decl_attribute) { } DECL_ATTRIBUTE_PROC(var_decl_attribute) { - if (c->context.curr_proc_decl != nullptr) { + if (c->curr_proc_decl != nullptr) { error(elem, "Only a variable at file scope can have a '%.*s'", LIT(name)); return true; } @@ -1770,7 +1776,7 @@ DECL_ATTRIBUTE_PROC(var_decl_attribute) { } else if (name == "thread_local") { if (ac->init_expr_list_count > 0) { error(elem, "A thread local variable declaration cannot have initialization values"); - } else if (c->context.foreign_context.curr_library || c->context.foreign_context.in_export) { + } else if (c->foreign_context.curr_library || c->foreign_context.in_export) { error(elem, "A foreign block variable cannot be thread local"); } else if (value.kind == ExactValue_Invalid) { ac->thread_local_model = str_lit("default"); @@ -1801,7 +1807,7 @@ DECL_ATTRIBUTE_PROC(var_decl_attribute) { -void check_decl_attributes(Checker *c, Array<AstNode *> attributes, DeclAttributeProc *proc, AttributeContext *ac) { +void check_decl_attributes(CheckerContext *c, Array<AstNode *> attributes, DeclAttributeProc *proc, AttributeContext *ac) { if (attributes.count == 0) return; String original_link_prefix = {}; @@ -1872,7 +1878,7 @@ void check_decl_attributes(Checker *c, Array<AstNode *> attributes, DeclAttribut } -bool check_arity_match(Checker *c, AstNodeValueDecl *vd, bool is_global) { +bool check_arity_match(CheckerContext *c, AstNodeValueDecl *vd, bool is_global) { isize lhs = vd->names.count; isize rhs = vd->values.count; @@ -1908,7 +1914,7 @@ bool check_arity_match(Checker *c, AstNodeValueDecl *vd, bool is_global) { return true; } -void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { +void check_collect_entities_from_when_stmt(CheckerContext *c, AstNodeWhenStmt *ws) { Operand operand = {Addressing_Invalid}; if (!ws->is_cond_determined) { check_expr(c, &operand, ws->cond); @@ -1944,14 +1950,14 @@ void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { } } -void check_collect_value_decl(Checker *c, AstNode *decl) { +void check_collect_value_decl(CheckerContext *c, AstNode *decl) { ast_node(vd, ValueDecl, decl); if (vd->been_handled) return; vd->been_handled = true; if (vd->is_mutable) { - if (!c->context.scope->is_file) { + if (!c->scope->is_file) { // NOTE(bill): local scope -> handle later and in order return; } @@ -1962,7 +1968,7 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_cap); DeclInfo *di = nullptr; if (vd->values.count > 0) { - di = make_decl_info(heap_allocator(), c->context.scope, c->context.decl); + di = make_decl_info(heap_allocator(), c->scope, c->decl); di->entities = entities; di->type_expr = vd->type; di->init_expr = vd->values[0]; @@ -1979,7 +1985,7 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { error(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); continue; } - Entity *e = alloc_entity_variable(c->context.scope, name->Ident.token, nullptr, false); + Entity *e = alloc_entity_variable(c->scope, name->Ident.token, nullptr, false); e->identifier = name; if (vd->is_using) { @@ -1987,15 +1993,15 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { error(name, "'using' is not allowed at the file scope"); } - AstNode *fl = c->context.foreign_context.curr_library; + AstNode *fl = c->foreign_context.curr_library; if (fl != nullptr) { GB_ASSERT(fl->kind == AstNode_Ident); e->Variable.is_foreign = true; e->Variable.foreign_library_ident = fl; - e->Variable.link_prefix = c->context.foreign_context.link_prefix; + e->Variable.link_prefix = c->foreign_context.link_prefix; - } else if (c->context.foreign_context.in_export) { + } else if (c->foreign_context.in_export) { e->Variable.is_export = true; } @@ -2004,7 +2010,7 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { DeclInfo *d = di; if (d == nullptr || i > 0) { AstNode *init_expr = value; - d = make_decl_info(heap_allocator(), e->scope, c->context.decl); + d = make_decl_info(heap_allocator(), e->scope, c->decl); d->type_expr = vd->type; d->init_expr = init_expr; } @@ -2034,8 +2040,8 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { Token token = name->Ident.token; - AstNode *fl = c->context.foreign_context.curr_library; - DeclInfo *d = make_decl_info(c->allocator, c->context.scope, c->context.decl); + AstNode *fl = c->foreign_context.curr_library; + DeclInfo *d = make_decl_info(c->allocator, c->scope, c->decl); Entity *e = nullptr; d->attributes = vd->attributes; @@ -2049,7 +2055,7 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { d->type_expr = init; d->init_expr = init; } else if (init->kind == AstNode_ProcLit) { - if (c->context.scope->is_struct) { + if (c->scope->is_struct) { error(name, "Procedure declarations are not allowed within a struct"); continue; } @@ -2064,16 +2070,16 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { auto cc = pl->type->ProcType.calling_convention; if (cc == ProcCC_ForeignBlockDefault) { cc = ProcCC_CDecl; - if (c->context.foreign_context.default_cc > 0) { - cc = c->context.foreign_context.default_cc; + if (c->foreign_context.default_cc > 0) { + cc = c->foreign_context.default_cc; } } - e->Procedure.link_prefix = c->context.foreign_context.link_prefix; + e->Procedure.link_prefix = c->foreign_context.link_prefix; GB_ASSERT(cc != ProcCC_Invalid); pl->type->ProcType.calling_convention = cc; - } else if (c->context.foreign_context.in_export) { + } else if (c->foreign_context.in_export) { e->Procedure.is_export = true; } d->proc_lit = init; @@ -2093,7 +2099,7 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { e->identifier = name; if (e->kind != Entity_Procedure) { - if (fl != nullptr || c->context.foreign_context.in_export) { + if (fl != nullptr || c->foreign_context.in_export) { AstNodeKind kind = init->kind; error(name, "Only procedures and variables are allowed to be in a foreign block, got %.*s", LIT(ast_node_strings[kind])); if (kind == AstNode_ProcType) { @@ -2110,7 +2116,7 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { } } -void check_add_foreign_block_decl(Checker *c, AstNode *decl) { +void check_add_foreign_block_decl(CheckerContext *ctx, AstNode *decl) { ast_node(fb, ForeignBlockDecl, decl); if (fb->been_handled) return; @@ -2118,36 +2124,35 @@ void check_add_foreign_block_decl(Checker *c, AstNode *decl) { AstNode *foreign_library = fb->foreign_library; - CheckerContext prev_context = c->context; + CheckerContext c = *ctx; if (foreign_library->kind == AstNode_Ident) { - c->context.foreign_context.curr_library = foreign_library; + c.foreign_context.curr_library = foreign_library; } else if (foreign_library->kind == AstNode_Implicit && foreign_library->Implicit.kind == Token_export) { - c->context.foreign_context.in_export = true; + c.foreign_context.in_export = true; } else { error(foreign_library, "Foreign block name must be an identifier or 'export'"); - c->context.foreign_context.curr_library = nullptr; + c.foreign_context.curr_library = nullptr; } - check_decl_attributes(c, fb->attributes, foreign_block_decl_attribute, nullptr); + check_decl_attributes(&c, fb->attributes, foreign_block_decl_attribute, nullptr); - check_collect_entities(c, fb->decls); - c->context = prev_context; + check_collect_entities(&c, fb->decls); } // NOTE(bill): If file_scopes == nullptr, this will act like a local scope -void check_collect_entities(Checker *c, Array<AstNode *> nodes) { +void check_collect_entities(CheckerContext *c, Array<AstNode *> nodes) { for_array(decl_index, nodes) { AstNode *decl = nodes[decl_index]; - if (c->context.scope->is_file) { + if (c->scope->is_file) { } if (!is_ast_node_decl(decl) && !is_ast_node_when_stmt(decl)) { - if (c->context.scope->is_file && decl->kind == AstNode_ExprStmt) { + if (c->scope->is_file && decl->kind == AstNode_ExprStmt) { AstNode *expr = decl->ExprStmt.expr; if (expr->kind == AstNode_CallExpr && expr->CallExpr.proc->kind == AstNode_BasicDirective && expr->CallExpr.proc->BasicDirective.name == "assert") { - array_add(&c->context.scope->delayed_asserts, expr); + array_add(&c->scope->delayed_asserts, expr); continue; } } @@ -2167,17 +2172,17 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes) { case_end; case_ast_node(id, ImportDecl, decl); - if (!c->context.scope->is_file) { + if (!c->scope->is_file) { error(decl, "import declarations are only allowed in the file scope"); // NOTE(bill): _Should_ be caught by the parser // TODO(bill): Better error handling if it isn't continue; } - array_add(&c->context.scope->delayed_imports, decl); + array_add(&c->scope->delayed_imports, decl); case_end; case_ast_node(fl, ForeignImportDecl, decl); - if (!c->context.scope->is_file) { + if (!c->scope->is_file) { error(decl, "%.*s declarations are only allowed in the file scope", LIT(fl->token.string)); // NOTE(bill): _Should_ be caught by the parser // TODO(bill): Better error handling if it isn't @@ -2191,7 +2196,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes) { case_end; default: - if (c->context.scope->is_file) { + if (c->scope->is_file) { error(decl, "Only declarations are allowed at file scope"); } break; @@ -2200,7 +2205,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes) { // NOTE(bill): 'when' stmts need to be handled after the other as the condition may refer to something // declared after this stmt in source - if (!c->context.scope->is_file) { + if (!c->scope->is_file) { for_array(i, nodes) { AstNode *node = nodes[i]; switch (node->kind) { @@ -2215,8 +2220,8 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes) { void check_all_global_entities(Checker *c) { Scope *prev_file = nullptr; - bool processing_preload = true; + for_array(i, c->info.entities) { Entity *e = c->info.entities[i]; DeclInfo *d = e->decl_info; @@ -2226,10 +2231,14 @@ void check_all_global_entities(Checker *c) { } + CheckerContext ctx = c->init_ctx; + GB_ASSERT(d->scope->is_file); AstFile *file = d->scope->file; - add_curr_ast_file(c, file); + add_curr_ast_file(&ctx, file); Scope *package_scope = file->pkg->scope; + GB_ASSERT(ctx.pkg != nullptr); + GB_ASSERT(e->pkg != nullptr); if (e->token.string == "main") { if (e->kind != Entity_Procedure) { @@ -2243,11 +2252,9 @@ void check_all_global_entities(Checker *c) { } } - CheckerContext prev_context = c->context; - c->context.decl = d; - c->context.scope = d->scope; - check_entity_decl(c, e, d, nullptr); - c->context = prev_context; + ctx.decl = d; + ctx.scope = d->scope; + check_entity_decl(&ctx, e, d, nullptr); if (!package_scope->is_global) { @@ -2490,19 +2497,24 @@ Array<ImportPathItem> find_import_path(Checker *c, Scope *start, Scope *end, Ptr return empty_path; } #endif -void check_add_import_decl(Checker *c, AstNodeImportDecl *id) { +void check_add_import_decl(CheckerContext *ctx, AstNodeImportDecl *id) { if (id->been_handled) return; id->been_handled = true; - Scope *parent_scope = c->context.scope; + gb_mutex_lock(&ctx->checker->mutex); + defer (gb_mutex_unlock(&ctx->checker->mutex)); + + Scope *parent_scope = ctx->scope; GB_ASSERT(parent_scope->is_file); + auto *pkg_scopes = &ctx->checker->package_scopes; + Token token = id->relpath; HashKey key = hash_string(id->fullpath); - Scope **found = map_get(&c->package_scopes, key); + Scope **found = map_get(pkg_scopes, key); if (found == nullptr) { - for_array(scope_index, c->package_scopes.entries) { - Scope *scope = c->package_scopes.entries[scope_index].value; + for_array(scope_index, pkg_scopes->entries) { + Scope *scope = pkg_scopes->entries[scope_index].value; gb_printf_err("%.*s\n", LIT(scope->package->fullpath)); } gb_printf_err("%.*s(%td:%td)\n", LIT(token.pos.file), token.pos.line, token.pos.column); @@ -2542,9 +2554,9 @@ void check_add_import_decl(Checker *c, AstNodeImportDecl *id) { id->fullpath, id->import_name.string, scope); - add_entity(c, parent_scope, nullptr, e); + add_entity(ctx->checker, parent_scope, nullptr, e); if (id->is_using) { - add_entity_use(c, nullptr, e); + add_entity_use(ctx, nullptr, e); } } } @@ -2578,8 +2590,8 @@ void check_add_import_decl(Checker *c, AstNodeImportDecl *id) { bool implicit_is_found = ptr_set_exists(&scope->implicit, e); if (is_entity_exported(e) && !implicit_is_found) { - add_entity_use(c, node, e); - bool ok = add_entity(c, parent_scope, e->identifier, e); + add_entity_use(ctx, node, e); + bool ok = add_entity(ctx->checker, parent_scope, e->identifier, e); if (ok) ptr_set_add(&parent_scope->implicit, e); } else { error(node, "'%.*s' is exported from this scope", LIT(name)); @@ -2594,8 +2606,7 @@ void check_add_import_decl(Checker *c, AstNodeImportDecl *id) { bool implicit_is_found = ptr_set_exists(&scope->implicit, e); if (is_entity_exported(e) && !implicit_is_found) { Entity *prev = scope_lookup_entity(parent_scope, e->token.string); - // if (prev) gb_printf_err("%.*s\n", LIT(prev->token.string)); - bool ok = add_entity(c, parent_scope, e->identifier, e); + bool ok = add_entity(ctx->checker, parent_scope, e->identifier, e); if (ok) ptr_set_add(&parent_scope->implicit, e); } } @@ -2606,13 +2617,13 @@ void check_add_import_decl(Checker *c, AstNodeImportDecl *id) { } -void check_add_foreign_import_decl(Checker *c, AstNode *decl) { +void check_add_foreign_import_decl(CheckerContext *ctx, AstNode *decl) { ast_node(fl, ForeignImportDecl, decl); if (fl->been_handled) return; fl->been_handled = true; - Scope *parent_scope = c->context.scope; + Scope *parent_scope = ctx->scope; GB_ASSERT(parent_scope->is_file); String fullpath = fl->fullpath; @@ -2646,7 +2657,7 @@ void check_add_foreign_import_decl(Checker *c, AstNode *decl) { fl->library_name.string = library_name; Entity *e = alloc_entity_library_name(parent_scope, fl->library_name, t_invalid, fl->fullpath, library_name); - add_entity(c, parent_scope, nullptr, e); + add_entity(ctx->checker, parent_scope, nullptr, e); } @@ -2733,25 +2744,24 @@ void check_import_entities(Checker *c) { for_array(i, p->files) { AstFile *f = p->files[i]; - CheckerContext prev_context = c->context; - defer (c->context = prev_context); - add_curr_ast_file(c, f); + CheckerContext ctx = c->init_ctx; + + add_curr_ast_file(&ctx, f); for_array(j, f->scope->delayed_imports) { AstNode *decl = f->scope->delayed_imports[j]; ast_node(id, ImportDecl, decl); - check_add_import_decl(c, id); + check_add_import_decl(&ctx, id); } } for_array(i, p->files) { AstFile *f = p->files[i]; - CheckerContext prev_context = c->context; - defer (c->context = prev_context); - add_curr_ast_file(c, f); + CheckerContext ctx = c->init_ctx; + add_curr_ast_file(&ctx, f); for_array(j, f->scope->delayed_asserts) { AstNode *expr = f->scope->delayed_asserts[j]; Operand o = {}; - check_expr(c, &o, expr); + check_expr(&ctx, &o, expr); } } } @@ -2913,13 +2923,13 @@ void check_parsed_files(Checker *c) { TIME_SECTION("map full filepaths to scope"); - add_type_info_type(c, t_invalid); + add_type_info_type(&c->init_ctx, t_invalid); // Map full filepaths to Scopes for_array(i, c->parser->packages) { AstPackage *p = c->parser->packages[i]; - Scope *scope = create_scope_from_package(c, p); - p->decl_info = make_decl_info(c->allocator, scope, c->context.decl); + Scope *scope = create_scope_from_package(&c->init_ctx, p); + p->decl_info = make_decl_info(c->allocator, scope, c->init_ctx.decl); HashKey key = hash_string(p->fullpath); map_set(&c->package_scopes, key, scope); map_set(&c->info.packages, key, p); @@ -2937,17 +2947,20 @@ void check_parsed_files(Checker *c) { // Collect Entities for_array(i, c->parser->packages) { AstPackage *p = c->parser->packages[i]; - CheckerContext prev_context = c->context; + + CheckerContext ctx = make_checker_context(c); + defer (destroy_checker_context(&ctx)); + ctx.pkg = p; + for_array(j, p->files) { AstFile *f = p->files[j]; - create_scope_from_file(c, f); + create_scope_from_file(&ctx, f); HashKey key = hash_string(f->fullpath); map_set(&c->info.files, key, f); - add_curr_ast_file(c, f); - check_collect_entities(c, f->decls); + add_curr_ast_file(&ctx, f); + check_collect_entities(&ctx, f->decls); } - c->context = prev_context; } TIME_SECTION("import entities"); @@ -2959,6 +2972,9 @@ void check_parsed_files(Checker *c) { TIME_SECTION("init preload"); init_preload(c); // NOTE(bill): This could be setup previously through the use of 'type_info_of' + CheckerContext prev_context = c->init_ctx; + defer (c->init_ctx = prev_context); + TIME_SECTION("check procedure bodies"); // NOTE(bill): Nested procedures bodies will be added to this "queue" for_array(i, c->procs_to_check) { @@ -2966,8 +2982,10 @@ void check_parsed_files(Checker *c) { if (pi->type == nullptr) { continue; } - CheckerContext prev_context = c->context; - defer (c->context = prev_context); + + CheckerContext ctx = make_checker_context(c); + defer (destroy_checker_context(&ctx)); + add_curr_ast_file(&ctx, pi->file); TypeProc *pt = &pi->type->Proc; String name = pi->token.string; @@ -2975,22 +2993,22 @@ void check_parsed_files(Checker *c) { GB_ASSERT_MSG(pt->is_poly_specialized, "%.*s", LIT(name)); } - add_curr_ast_file(c, pi->file); bool bounds_check = (pi->tags & ProcTag_bounds_check) != 0; bool no_bounds_check = (pi->tags & ProcTag_no_bounds_check) != 0; if (bounds_check) { - c->context.stmt_state_flags |= StmtStateFlag_bounds_check; - c->context.stmt_state_flags &= ~StmtStateFlag_no_bounds_check; + ctx.stmt_state_flags |= StmtStateFlag_bounds_check; + ctx.stmt_state_flags &= ~StmtStateFlag_no_bounds_check; } else if (no_bounds_check) { - c->context.stmt_state_flags |= StmtStateFlag_no_bounds_check; - c->context.stmt_state_flags &= ~StmtStateFlag_bounds_check; + ctx.stmt_state_flags |= StmtStateFlag_no_bounds_check; + ctx.stmt_state_flags &= ~StmtStateFlag_bounds_check; } - check_proc_body(c, pi->token, pi->decl, pi->type, pi->body); + check_proc_body(&ctx, pi->token, pi->decl, pi->type, pi->body); } + for_array(i, c->info.files.entries) { AstFile *f = c->info.files.entries[i].value; check_scope_usage(c, f->scope); @@ -3030,7 +3048,7 @@ void check_parsed_files(Checker *c) { Type *t = &basic_types[i]; if (t->Basic.size > 0 && (t->Basic.flags & BasicFlag_LLVM) == 0) { - add_type_info_type(c, t); + add_type_info_type(&c->init_ctx, t); } } @@ -3041,7 +3059,7 @@ void check_parsed_files(Checker *c) { // i64 size = type_size_of(c->allocator, e->type); i64 align = type_align_of(e->type); if (align > 0 && ptr_set_exists(&c->info.minimum_dependency_set, e)) { - add_type_info_type(c, e->type); + add_type_info_type(&c->init_ctx, e->type); } } } diff --git a/src/checker.hpp b/src/checker.hpp index 8d580ca97..b7fc2fc78 100644 --- a/src/checker.hpp +++ b/src/checker.hpp @@ -31,16 +31,19 @@ struct TypeAndValue { // ExprInfo stores information used for "untyped" expressions -struct ExprInfo : TypeAndValue { +struct ExprInfo { + AddressingMode mode; + Type * type; + ExactValue value; bool is_lhs; // Debug info }; gb_inline ExprInfo make_expr_info(AddressingMode mode, Type *type, ExactValue value, bool is_lhs) { ExprInfo ei = {}; - ei.is_lhs = is_lhs; ei.mode = mode; ei.type = type; ei.value = value; + ei.is_lhs = is_lhs; return ei; } @@ -289,6 +292,7 @@ struct CheckerContext { DeclInfo * curr_proc_decl; Type * curr_proc_sig; ForeignContext foreign_context; + gbAllocator allocator; CheckerTypePath *type_path; isize type_level; // TODO(bill): Actually handle correctly @@ -337,7 +341,7 @@ struct Checker { gbAllocator allocator; - CheckerContext context; + CheckerContext init_ctx; bool done_preload; }; @@ -379,20 +383,20 @@ void check_set_expr_info (CheckerInfo *i, AstNode *expr, ExprInfo info) void check_remove_expr_info (CheckerInfo *i, AstNode *expr); void add_untyped (CheckerInfo *i, AstNode *expression, bool lhs, AddressingMode mode, Type *basic_type, ExactValue value); void add_type_and_value (CheckerInfo *i, AstNode *expression, AddressingMode mode, Type *type, ExactValue value); -void add_entity_use (Checker *c, AstNode *identifier, Entity *entity); -void add_implicit_entity (Checker *c, AstNode *node, Entity *e); -void add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclInfo *d); -void add_type_info_type (Checker *c, Type *t); +void add_entity_use (CheckerContext *c, AstNode *identifier, Entity *entity); +void add_implicit_entity (CheckerContext *c, AstNode *node, Entity *e); +void add_entity_and_decl_info(CheckerContext *c, AstNode *identifier, Entity *e, DeclInfo *d); +void add_type_info_type (CheckerContext *c, Type *t); -void check_add_import_decl(Checker *c, AstNodeImportDecl *id); +void check_add_import_decl(CheckerContext *c, AstNodeImportDecl *id); // void check_add_export_decl(Checker *c, AstNodeExportDecl *ed); -void check_add_foreign_import_decl(Checker *c, AstNode *decl); +void check_add_foreign_import_decl(CheckerContext *c, AstNode *decl); -bool check_arity_match(Checker *c, AstNodeValueDecl *vd, bool is_global = false); -void check_collect_entities(Checker *c, Array<AstNode *> nodes); -void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws); -void check_delayed_file_import_entity(Checker *c, AstNode *decl); +bool check_arity_match(CheckerContext *c, AstNodeValueDecl *vd, bool is_global = false); +void check_collect_entities(CheckerContext *c, Array<AstNode *> nodes); +void check_collect_entities_from_when_stmt(CheckerContext *c, AstNodeWhenStmt *ws); +void check_delayed_file_import_entity(CheckerContext *c, AstNode *decl); struct AttributeContext { String link_name; @@ -408,13 +412,13 @@ AttributeContext make_attribute_context(String link_prefix) { return ac; } -#define DECL_ATTRIBUTE_PROC(_name) bool _name(Checker *c, AstNode *elem, String name, ExactValue value, AttributeContext *ac) +#define DECL_ATTRIBUTE_PROC(_name) bool _name(CheckerContext *c, AstNode *elem, String name, ExactValue value, AttributeContext *ac) typedef DECL_ATTRIBUTE_PROC(DeclAttributeProc); -void check_decl_attributes(Checker *c, Array<AstNode *> attributes, DeclAttributeProc *proc, AttributeContext *ac); +void check_decl_attributes(CheckerContext *c, Array<AstNode *> attributes, DeclAttributeProc *proc, AttributeContext *ac); CheckerTypePath *new_checker_type_path(); void destroy_checker_type_path(CheckerTypePath *tp); -void check_type_path_push(Checker *c, Entity *e); -Entity *check_type_path_pop (Checker *c); +void check_type_path_push(CheckerContext *c, Entity *e); +Entity *check_type_path_pop (CheckerContext *c); diff --git a/src/ir.cpp b/src/ir.cpp index 87525028d..e773be111 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -3833,14 +3833,16 @@ String ir_mangle_name(irGen *s, Entity *e) { return make_string(new_name, new_name_len-1); #else - GB_ASSERT(e->pkg != nullptr); - String pkg = e->pkg->name; - GB_ASSERT(!rune_is_digit(pkg[0])); - String name = e->token.string; + AstPackage *pkg = e->pkg; + GB_ASSERT_MSG(pkg != nullptr, "Missing package for '%.*s'", LIT(name)); + String pkgn = pkg->name; + GB_ASSERT(!rune_is_digit(pkgn[0])); + + - isize max_len = pkg.len + 1 + name.len + 1; + isize max_len = pkgn.len + 1 + name.len + 1; bool require_suffix_id = is_type_polymorphic(e->type); if (require_suffix_id) { max_len += 21; @@ -3849,7 +3851,7 @@ String ir_mangle_name(irGen *s, Entity *e) { u8 *new_name = gb_alloc_array(a, u8, max_len); isize new_name_len = gb_snprintf( cast(char *)new_name, max_len, - "%.*s.%.*s", LIT(pkg), LIT(name) + "%.*s.%.*s", LIT(pkgn), LIT(name) ); if (require_suffix_id) { char *str = cast(char *)new_name + new_name_len-1; |