aboutsummaryrefslogtreecommitdiff
path: root/src/checker.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/checker.cpp')
-rw-r--r--src/checker.cpp250
1 files changed, 125 insertions, 125 deletions
diff --git a/src/checker.cpp b/src/checker.cpp
index a59592e46..4efbcab45 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -1,7 +1,7 @@
#include "entity.cpp"
#include "types.cpp"
-void check_expr(CheckerContext *c, Operand *operand, AstNode *expression);
+void check_expr(CheckerContext *c, Operand *operand, Ast *expression);
bool is_operand_value(Operand o) {
@@ -165,10 +165,10 @@ void import_graph_node_swap(ImportGraphNode **data, isize i, isize j) {
}
GB_COMPARE_PROC(ast_node_cmp) {
- AstNode *x = *cast(AstNode **)a;
- AstNode *y = *cast(AstNode **)b;
- Token i = ast_node_token(x);
- Token j = ast_node_token(y);
+ Ast *x = *cast(Ast **)a;
+ Ast *y = *cast(Ast **)b;
+ Token i = ast_token(x);
+ Token j = ast_token(y);
return token_pos_cmp(i.pos, j.pos);
}
@@ -307,7 +307,7 @@ void destroy_scope(Scope *scope) {
}
-void add_scope(CheckerContext *c, AstNode *node, Scope *scope) {
+void add_scope(CheckerContext *c, Ast *node, Scope *scope) {
GB_ASSERT(node != nullptr);
GB_ASSERT(scope != nullptr);
scope->node = node;
@@ -315,20 +315,20 @@ void add_scope(CheckerContext *c, AstNode *node, Scope *scope) {
}
-void check_open_scope(CheckerContext *c, AstNode *node) {
+void check_open_scope(CheckerContext *c, Ast *node) {
node = unparen_expr(node);
- GB_ASSERT(node->kind == AstNode_Invalid ||
- is_ast_node_stmt(node) ||
- is_ast_node_type(node));
+ GB_ASSERT(node->kind == Ast_Invalid ||
+ is_ast_stmt(node) ||
+ is_ast_type(node));
Scope *scope = create_scope(c->scope, c->allocator);
add_scope(c, node, scope);
switch (node->kind) {
- case AstNode_ProcType:
+ case Ast_ProcType:
scope->is_proc = true;
break;
- case AstNode_StructType:
- case AstNode_EnumType:
- case AstNode_UnionType:
+ case Ast_StructType:
+ case Ast_EnumType:
+ case Ast_UnionType:
scope->is_struct = true;
break;
}
@@ -662,26 +662,26 @@ void destroy_checker(Checker *c) {
}
-Entity *entity_of_ident(AstNode *identifier) {
- if (identifier->kind == AstNode_Ident) {
+Entity *entity_of_ident(Ast *identifier) {
+ if (identifier->kind == Ast_Ident) {
return identifier->Ident.entity;
}
return nullptr;
}
-TypeAndValue type_and_value_of_expr(CheckerInfo *i, AstNode *expr) {
+TypeAndValue type_and_value_of_expr(CheckerInfo *i, Ast *expr) {
TypeAndValue result = {};
TypeAndValue *found = map_get(&i->types, hash_node(expr));
if (found) result = *found;
return result;
}
-Type *type_of_expr(CheckerInfo *i, AstNode *expr) {
+Type *type_of_expr(CheckerInfo *i, Ast *expr) {
TypeAndValue tav = type_and_value_of_expr(i, expr);
if (tav.mode != Addressing_Invalid) {
return tav.type;
}
- if (expr->kind == AstNode_Ident) {
+ if (expr->kind == Ast_Ident) {
Entity *entity = entity_of_ident(expr);
if (entity) {
return entity->type;
@@ -691,12 +691,12 @@ Type *type_of_expr(CheckerInfo *i, AstNode *expr) {
return nullptr;
}
-Entity *implicit_entity_of_node(CheckerInfo *i, AstNode *clause) {
+Entity *implicit_entity_of_node(CheckerInfo *i, Ast *clause) {
// Entity **found = map_get(&i->implicits, hash_node(clause));
// if (found != nullptr) {
// return *found;
// }
- if (clause->kind == AstNode_CaseClause) {
+ if (clause->kind == Ast_CaseClause) {
return clause->CaseClause.implicit_entity;
}
return nullptr;
@@ -707,15 +707,15 @@ bool is_entity_implicitly_imported(Entity *import_name, Entity *e) {
}
// Will return nullptr if not found
-Entity *entity_of_node(CheckerInfo *i, AstNode *expr) {
+Entity *entity_of_node(CheckerInfo *i, Ast *expr) {
expr = unparen_expr(expr);
switch (expr->kind) {
case_ast_node(ident, Ident, expr);
return entity_of_ident(expr);
case_end;
case_ast_node(se, SelectorExpr, expr);
- AstNode *s = unselector_expr(se->selector);
- if (s->kind == AstNode_Ident) {
+ Ast *s = unselector_expr(se->selector);
+ if (s->kind == Ast_Ident) {
return entity_of_ident(s);
}
case_end;
@@ -734,7 +734,7 @@ DeclInfo *decl_info_of_entity(Entity *e) {
return nullptr;
}
-DeclInfo *decl_info_of_ident(AstNode *ident) {
+DeclInfo *decl_info_of_ident(Ast *ident) {
return decl_info_of_entity(entity_of_ident(ident));
}
@@ -745,16 +745,16 @@ AstFile *ast_file_of_filename(CheckerInfo *i, String filename) {
}
return nullptr;
}
-Scope *scope_of_node(AstNode *node) {
+Scope *scope_of_node(Ast *node) {
return node->scope;
}
-ExprInfo *check_get_expr_info(CheckerInfo *i, AstNode *expr) {
+ExprInfo *check_get_expr_info(CheckerInfo *i, Ast *expr) {
return map_get(&i->untyped, hash_node(expr));
}
-void check_set_expr_info(CheckerInfo *i, AstNode *expr, ExprInfo info) {
+void check_set_expr_info(CheckerInfo *i, Ast *expr, ExprInfo info) {
map_set(&i->untyped, hash_node(expr), info);
}
-void check_remove_expr_info(CheckerInfo *i, AstNode *expr) {
+void check_remove_expr_info(CheckerInfo *i, Ast *expr) {
map_remove(&i->untyped, hash_node(expr));
}
@@ -794,7 +794,7 @@ isize type_info_index(CheckerInfo *info, Type *type, bool error_on_failure) {
}
-void add_untyped(CheckerInfo *i, AstNode *expression, bool lhs, AddressingMode mode, Type *type, ExactValue value) {
+void add_untyped(CheckerInfo *i, Ast *expression, bool lhs, AddressingMode mode, Type *type, ExactValue value) {
if (expression == nullptr) {
return;
}
@@ -807,7 +807,7 @@ void add_untyped(CheckerInfo *i, AstNode *expression, bool lhs, AddressingMode m
map_set(&i->untyped, hash_node(expression), make_expr_info(mode, type, value, lhs));
}
-void add_type_and_value(CheckerInfo *i, AstNode *expression, AddressingMode mode, Type *type, ExactValue value) {
+void add_type_and_value(CheckerInfo *i, Ast *expression, AddressingMode mode, Type *type, ExactValue value) {
if (expression == nullptr) {
return;
}
@@ -825,9 +825,9 @@ void add_type_and_value(CheckerInfo *i, AstNode *expression, AddressingMode mode
map_set(&i->types, hash_node(expression), tv);
}
-void add_entity_definition(CheckerInfo *i, AstNode *identifier, Entity *entity) {
+void add_entity_definition(CheckerInfo *i, Ast *identifier, Entity *entity) {
GB_ASSERT(identifier != nullptr);
- GB_ASSERT(identifier->kind == AstNode_Ident);
+ GB_ASSERT(identifier->kind == Ast_Ident);
if (is_blank_ident(identifier)) {
return;
}
@@ -842,7 +842,7 @@ void add_entity_definition(CheckerInfo *i, AstNode *identifier, Entity *entity)
array_add(&i->definitions, entity);
}
-bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) {
+bool add_entity(Checker *c, Scope *scope, Ast *identifier, Entity *entity) {
if (scope == nullptr) {
return false;
}
@@ -883,12 +883,12 @@ bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) {
return true;
}
-void add_entity_use(CheckerContext *c, AstNode *identifier, Entity *entity) {
+void add_entity_use(CheckerContext *c, Ast *identifier, Entity *entity) {
if (entity == nullptr) {
return;
}
if (identifier != nullptr) {
- if (identifier->kind != AstNode_Ident) {
+ if (identifier->kind != Ast_Ident) {
return;
}
if (entity->identifier == nullptr) {
@@ -906,8 +906,8 @@ void add_entity_use(CheckerContext *c, AstNode *identifier, Entity *entity) {
}
-void add_entity_and_decl_info(CheckerContext *c, AstNode *identifier, Entity *e, DeclInfo *d) {
- GB_ASSERT(identifier->kind == AstNode_Ident);
+void add_entity_and_decl_info(CheckerContext *c, Ast *identifier, Entity *e, DeclInfo *d) {
+ GB_ASSERT(identifier->kind == Ast_Ident);
GB_ASSERT(e != nullptr && d != nullptr);
GB_ASSERT(identifier->Ident.token.string == e->token.string);
@@ -931,10 +931,10 @@ void add_entity_and_decl_info(CheckerContext *c, AstNode *identifier, Entity *e,
}
-void add_implicit_entity(CheckerContext *c, AstNode *clause, Entity *e) {
+void add_implicit_entity(CheckerContext *c, Ast *clause, Entity *e) {
GB_ASSERT(clause != nullptr);
GB_ASSERT(e != nullptr);
- GB_ASSERT(clause->kind == AstNode_CaseClause);
+ GB_ASSERT(clause->kind == Ast_CaseClause);
clause->CaseClause.implicit_entity = e;
}
@@ -1098,7 +1098,7 @@ void check_procedure_later(Checker *c, ProcInfo info) {
array_add(&c->procs_to_check, info);
}
-void check_procedure_later(Checker *c, AstFile *file, Token token, DeclInfo *decl, Type *type, AstNode *body, u64 tags) {
+void check_procedure_later(Checker *c, AstFile *file, Token token, DeclInfo *decl, Type *type, Ast *body, u64 tags) {
ProcInfo info = {};
info.file = file;
info.token = token;
@@ -1798,7 +1798,7 @@ DECL_ATTRIBUTE_PROC(var_decl_attribute) {
-void check_decl_attributes(CheckerContext *c, Array<AstNode *> const &attributes, DeclAttributeProc *proc, AttributeContext *ac) {
+void check_decl_attributes(CheckerContext *c, Array<Ast *> const &attributes, DeclAttributeProc *proc, AttributeContext *ac) {
if (attributes.count == 0) return;
String original_link_prefix = {};
@@ -1811,19 +1811,19 @@ void check_decl_attributes(CheckerContext *c, Array<AstNode *> const &attributes
defer (string_set_destroy(&set));
for_array(i, attributes) {
- AstNode *attr = attributes[i];
- if (attr->kind != AstNode_Attribute) continue;
+ Ast *attr = attributes[i];
+ if (attr->kind != Ast_Attribute) continue;
for_array(j, attr->Attribute.elems) {
- AstNode *elem = attr->Attribute.elems[j];
+ Ast *elem = attr->Attribute.elems[j];
String name = {};
- AstNode *value = nullptr;
+ Ast *value = nullptr;
switch (elem->kind) {
case_ast_node(i, Ident, elem);
name = i->token.string;
case_end;
case_ast_node(fv, FieldValue, elem);
- GB_ASSERT(fv->field->kind == AstNode_Ident);
+ GB_ASSERT(fv->field->kind == Ast_Ident);
name = fv->field->Ident.token.string;
value = fv->value;
case_end;
@@ -1869,7 +1869,7 @@ void check_decl_attributes(CheckerContext *c, Array<AstNode *> const &attributes
}
-bool check_arity_match(CheckerContext *c, AstNodeValueDecl *vd, bool is_global) {
+bool check_arity_match(CheckerContext *c, AstValueDecl *vd, bool is_global) {
isize lhs = vd->names.count;
isize rhs = vd->values.count;
@@ -1880,7 +1880,7 @@ bool check_arity_match(CheckerContext *c, AstNodeValueDecl *vd, bool is_global)
}
} else if (lhs < rhs) {
if (lhs < vd->values.count) {
- AstNode *n = vd->values[lhs];
+ Ast *n = vd->values[lhs];
gbString str = expr_to_string(n);
error(n, "Extra initial expression '%s'", str);
gb_string_free(str);
@@ -1890,13 +1890,13 @@ bool check_arity_match(CheckerContext *c, AstNodeValueDecl *vd, bool is_global)
return false;
} else if (lhs > rhs) {
if (!is_global && rhs != 1) {
- AstNode *n = vd->names[rhs];
+ Ast *n = vd->names[rhs];
gbString str = expr_to_string(n);
error(n, "Missing expression for '%s'", str);
gb_string_free(str);
return false;
} else if (is_global) {
- AstNode *n = vd->values[rhs-1];
+ Ast *n = vd->values[rhs-1];
error(n, "Expected %td expressions on the right hand side, got %td", lhs, rhs);
return false;
}
@@ -1905,7 +1905,7 @@ bool check_arity_match(CheckerContext *c, AstNodeValueDecl *vd, bool is_global)
return true;
}
-void check_collect_entities_from_when_stmt(CheckerContext *c, AstNodeWhenStmt *ws) {
+void check_collect_entities_from_when_stmt(CheckerContext *c, AstWhenStmt *ws) {
Operand operand = {Addressing_Invalid};
if (!ws->is_cond_determined) {
check_expr(c, &operand, ws->cond);
@@ -1920,17 +1920,17 @@ void check_collect_entities_from_when_stmt(CheckerContext *c, AstNodeWhenStmt *w
ws->determined_cond = operand.value.kind == ExactValue_Bool && operand.value.value_bool;
}
- if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) {
+ if (ws->body == nullptr || ws->body->kind != Ast_BlockStmt) {
error(ws->cond, "Invalid body for 'when' statement");
} else {
if (ws->determined_cond) {
check_collect_entities(c, ws->body->BlockStmt.stmts);
} else if (ws->else_stmt) {
switch (ws->else_stmt->kind) {
- case AstNode_BlockStmt:
+ case Ast_BlockStmt:
check_collect_entities(c, ws->else_stmt->BlockStmt.stmts);
break;
- case AstNode_WhenStmt:
+ case Ast_WhenStmt:
check_collect_entities_from_when_stmt(c, &ws->else_stmt->WhenStmt);
break;
default:
@@ -1941,7 +1941,7 @@ void check_collect_entities_from_when_stmt(CheckerContext *c, AstNodeWhenStmt *w
}
}
-void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array<AstNode *> *attributes) {
+void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array<Ast *> *attributes) {
switch (e->kind) {
case Entity_ProcGroup:
case Entity_Procedure:
@@ -1956,19 +1956,19 @@ void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array<AstNode *> *
}
for_array(j, *attributes) {
- AstNode *attr = (*attributes)[j];
- if (attr->kind != AstNode_Attribute) continue;
+ Ast *attr = (*attributes)[j];
+ if (attr->kind != Ast_Attribute) continue;
for (isize k = 0; k < attr->Attribute.elems.count; k++) {
- AstNode *elem = attr->Attribute.elems[k];
+ Ast *elem = attr->Attribute.elems[k];
String name = {};
- AstNode *value = nullptr;
+ Ast *value = nullptr;
switch (elem->kind) {
case_ast_node(i, Ident, elem);
name = i->token.string;
case_end;
case_ast_node(fv, FieldValue, elem);
- GB_ASSERT(fv->field->kind == AstNode_Ident);
+ GB_ASSERT(fv->field->kind == Ast_Ident);
name = fv->field->Ident.token.string;
value = fv->value;
case_end;
@@ -1991,8 +1991,8 @@ void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array<AstNode *> *
}
for (isize i = 0; i < attributes->count; i++) {
- AstNode *attr = (*attributes)[i];
- if (attr->kind != AstNode_Attribute) continue;
+ Ast *attr = (*attributes)[i];
+ if (attr->kind != Ast_Attribute) continue;
if (attr->Attribute.elems.count == 0) {
(*attributes)[i] = (*attributes)[attributes->count-1];
attributes->count--;
@@ -2001,7 +2001,7 @@ void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array<AstNode *> *
}
}
-void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
+void check_collect_value_decl(CheckerContext *c, Ast *decl) {
if (decl->been_handled) return;
decl->been_handled = true;
@@ -2027,13 +2027,13 @@ void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
}
for_array(i, vd->names) {
- AstNode *name = vd->names[i];
- AstNode *value = nullptr;
+ Ast *name = vd->names[i];
+ Ast *value = nullptr;
if (i < vd->values.count) {
value = vd->values[i];
}
- if (name->kind != AstNode_Ident) {
- error(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind]));
+ if (name->kind != Ast_Ident) {
+ error(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_strings[name->kind]));
continue;
}
Entity *e = alloc_entity_variable(c->scope, name->Ident.token, nullptr, false);
@@ -2044,9 +2044,9 @@ void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
error(name, "'using' is not allowed at the file scope");
}
- AstNode *fl = c->foreign_context.curr_library;
+ Ast *fl = c->foreign_context.curr_library;
if (fl != nullptr) {
- GB_ASSERT(fl->kind == AstNode_Ident);
+ GB_ASSERT(fl->kind == Ast_Ident);
e->Variable.is_foreign = true;
e->Variable.foreign_library_ident = fl;
@@ -2060,7 +2060,7 @@ void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
DeclInfo *d = di;
if (d == nullptr || i > 0) {
- AstNode *init_expr = value;
+ Ast *init_expr = value;
d = make_decl_info(heap_allocator(), e->scope, c->decl);
d->type_expr = vd->type;
d->init_expr = init_expr;
@@ -2077,13 +2077,13 @@ void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
check_arity_match(c, vd, true);
} else {
for_array(i, vd->names) {
- AstNode *name = vd->names[i];
- if (name->kind != AstNode_Ident) {
- error(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind]));
+ Ast *name = vd->names[i];
+ if (name->kind != Ast_Ident) {
+ error(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_strings[name->kind]));
continue;
}
- AstNode *init = unparen_expr(vd->values[i]);
+ Ast *init = unparen_expr(vd->values[i]);
if (init == nullptr) {
error(name, "Expected a value for this constant value declaration");
continue;
@@ -2091,21 +2091,21 @@ void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
Token token = name->Ident.token;
- AstNode *fl = c->foreign_context.curr_library;
+ Ast *fl = c->foreign_context.curr_library;
DeclInfo *d = make_decl_info(c->allocator, c->scope, c->decl);
Entity *e = nullptr;
d->attributes = vd->attributes;
- if (is_ast_node_type(init) ||
- (vd->type != nullptr && vd->type->kind == AstNode_TypeType)) {
+ if (is_ast_type(init) ||
+ (vd->type != nullptr && vd->type->kind == Ast_TypeType)) {
e = alloc_entity_type_name(d->scope, token, nullptr);
if (vd->type != nullptr) {
error(name, "A type declaration cannot have an type parameter");
}
d->type_expr = init;
d->init_expr = init;
- } else if (init->kind == AstNode_ProcLit) {
+ } else if (init->kind == Ast_ProcLit) {
if (c->scope->is_struct) {
error(name, "Procedure declarations are not allowed within a struct");
continue;
@@ -2113,11 +2113,11 @@ void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
ast_node(pl, ProcLit, init);
e = alloc_entity_procedure(d->scope, token, nullptr, pl->tags);
if (fl != nullptr) {
- GB_ASSERT(fl->kind == AstNode_Ident);
+ GB_ASSERT(fl->kind == Ast_Ident);
e->Procedure.foreign_library_ident = fl;
e->Procedure.is_foreign = true;
- GB_ASSERT(pl->type->kind == AstNode_ProcType);
+ GB_ASSERT(pl->type->kind == Ast_ProcType);
auto cc = pl->type->ProcType.calling_convention;
if (cc == ProcCC_ForeignBlockDefault) {
cc = ProcCC_CDecl;
@@ -2135,7 +2135,7 @@ void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
}
d->proc_lit = init;
d->type_expr = pl->type;
- } else if (init->kind == AstNode_ProcGroup) {
+ } else if (init->kind == Ast_ProcGroup) {
ast_node(pg, ProcGroup, init);
e = alloc_entity_proc_group(d->scope, token, nullptr);
if (fl != nullptr) {
@@ -2151,9 +2151,9 @@ void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
if (e->kind != Entity_Procedure) {
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) {
+ AstKind kind = init->kind;
+ error(name, "Only procedures and variables are allowed to be in a foreign block, got %.*s", LIT(ast_strings[kind]));
+ if (kind == Ast_ProcType) {
gb_printf_err("\tDid you forget to append '---' to the procedure?\n");
}
}
@@ -2168,17 +2168,17 @@ void check_collect_value_decl(CheckerContext *c, AstNode *decl) {
}
}
-void check_add_foreign_block_decl(CheckerContext *ctx, AstNode *decl) {
+void check_add_foreign_block_decl(CheckerContext *ctx, Ast *decl) {
if (decl->been_handled) return;
decl->been_handled = true;
ast_node(fb, ForeignBlockDecl, decl);
- AstNode *foreign_library = fb->foreign_library;
+ Ast *foreign_library = fb->foreign_library;
CheckerContext c = *ctx;
- if (foreign_library->kind == AstNode_Ident) {
+ if (foreign_library->kind == Ast_Ident) {
c.foreign_context.curr_library = foreign_library;
- } else if (foreign_library->kind == AstNode_Implicit && foreign_library->Implicit.kind == Token_export) {
+ } else if (foreign_library->kind == Ast_Implicit && foreign_library->Implicit.kind == Token_export) {
c.foreign_context.in_export = true;
} else {
error(foreign_library, "Foreign block name must be an identifier or 'export'");
@@ -2193,13 +2193,13 @@ void check_add_foreign_block_decl(CheckerContext *ctx, AstNode *decl) {
}
// NOTE(bill): If file_scopes == nullptr, this will act like a local scope
-void check_collect_entities(CheckerContext *c, Array<AstNode *> const &nodes) {
+void check_collect_entities(CheckerContext *c, Array<Ast *> const &nodes) {
for_array(decl_index, nodes) {
- AstNode *decl = nodes[decl_index];
- if (!is_ast_node_decl(decl) && !is_ast_node_when_stmt(decl)) {
- 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) {
+ Ast *decl = nodes[decl_index];
+ if (!is_ast_decl(decl) && !is_ast_when_stmt(decl)) {
+ if (c->scope->is_file && decl->kind == Ast_ExprStmt) {
+ Ast *expr = decl->ExprStmt.expr;
+ if (expr->kind == Ast_CallExpr && expr->CallExpr.proc->kind == Ast_BasicDirective) {
if (c->collect_delayed_decls) {
array_add(&c->scope->delayed_directives, expr);
}
@@ -2259,7 +2259,7 @@ void check_collect_entities(CheckerContext *c, Array<AstNode *> const &nodes) {
// declared after this stmt in source
if (!c->scope->is_file || c->collect_delayed_decls) {
for_array(i, nodes) {
- AstNode *node = nodes[i];
+ Ast *node = nodes[i];
switch (node->kind) {
case_ast_node(ws, WhenStmt, node);
check_collect_entities_from_when_stmt(c, ws);
@@ -2378,7 +2378,7 @@ String path_to_entity_name(String name, String fullpath) {
#if 1
-void add_import_dependency_node(Checker *c, AstNode *decl, Map<ImportGraphNode *> *M) {
+void add_import_dependency_node(Checker *c, Ast *decl, Map<ImportGraphNode *> *M) {
AstPackage *parent_pkg = decl->file->pkg;
switch (decl->kind) {
@@ -2391,7 +2391,7 @@ void add_import_dependency_node(Checker *c, AstNode *decl, Map<ImportGraphNode *
AstPackage *pkg = c->info.packages.entries[pkg_index].value;
gb_printf_err("%.*s\n", LIT(pkg->fullpath));
}
- Token token = ast_node_token(decl);
+ Token token = ast_token(decl);
gb_printf_err("%.*s(%td:%td)\n", LIT(token.pos.file), token.pos.line, token.pos.column);
GB_PANIC("Unable to find package: %.*s", LIT(path));
}
@@ -2428,7 +2428,7 @@ void add_import_dependency_node(Checker *c, AstNode *decl, Map<ImportGraphNode *
if (ws->else_stmt != nullptr) {
switch (ws->else_stmt->kind) {
- case AstNode_BlockStmt: {
+ case Ast_BlockStmt: {
auto stmts = ws->else_stmt->BlockStmt.stmts;
for_array(i, stmts) {
add_import_dependency_node(c, stmts[i], M);
@@ -2436,7 +2436,7 @@ void add_import_dependency_node(Checker *c, AstNode *decl, Map<ImportGraphNode *
break;
}
- case AstNode_WhenStmt:
+ case Ast_WhenStmt:
add_import_dependency_node(c, ws->else_stmt, M);
break;
}
@@ -2462,7 +2462,7 @@ Array<ImportGraphNode *> generate_import_dependency_graph(Checker *c) {
for_array(j, p->files) {
AstFile *f = p->files[j];
for_array(k, f->decls) {
- AstNode *decl = f->decls[k];
+ Ast *decl = f->decls[k];
add_import_dependency_node(c, decl, &M);
}
}
@@ -2484,7 +2484,7 @@ Array<ImportGraphNode *> generate_import_dependency_graph(Checker *c) {
struct ImportPathItem {
AstPackage *pkg;
- AstNode * decl;
+ Ast * decl;
};
Array<ImportPathItem> find_import_path(Checker *c, AstPackage *start, AstPackage *end, PtrSet<AstPackage *> *visited) {
@@ -2507,8 +2507,8 @@ Array<ImportPathItem> find_import_path(Checker *c, AstPackage *start, AstPackage
AstFile *f = pkg->files[i];
for_array(j, f->imports) {
AstPackage *pkg = nullptr;
- AstNode *decl = f->imports[j];
- if (decl->kind == AstNode_ImportDecl) {
+ Ast *decl = f->imports[j];
+ if (decl->kind == Ast_ImportDecl) {
pkg = decl->ImportDecl.package;
} else {
continue;
@@ -2537,7 +2537,7 @@ Array<ImportPathItem> find_import_path(Checker *c, AstPackage *start, AstPackage
return empty_path;
}
#endif
-void check_add_import_decl(CheckerContext *ctx, AstNode *decl) {
+void check_add_import_decl(CheckerContext *ctx, Ast *decl) {
if (decl->been_handled) return;
decl->been_handled = true;
@@ -2624,7 +2624,7 @@ void check_add_import_decl(CheckerContext *ctx, AstNode *decl) {
}
-void check_add_foreign_import_decl(CheckerContext *ctx, AstNode *decl) {
+void check_add_foreign_import_decl(CheckerContext *ctx, Ast *decl) {
if (decl->been_handled) return;
decl->been_handled = true;
@@ -2667,10 +2667,10 @@ void check_add_foreign_import_decl(CheckerContext *ctx, AstNode *decl) {
add_entity(ctx->checker, parent_scope, nullptr, e);
}
-bool collect_checked_packages_from_decl_list(Checker *c, Array<AstNode *> const &decls) {
+bool collect_checked_packages_from_decl_list(Checker *c, Array<Ast *> const &decls) {
bool new_files = false;
for_array(i, decls) {
- AstNode *decl = decls[i];
+ Ast *decl = decls[i];
switch (decl->kind) {
case_ast_node(id, ImportDecl, decl);
HashKey key = hash_string(id->fullpath);
@@ -2690,10 +2690,10 @@ bool collect_checked_packages_from_decl_list(Checker *c, Array<AstNode *> const
}
// Returns true if a new package is present
-bool collect_file_decls(CheckerContext *ctx, Array<AstNode *> const &decls);
-bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstNodeWhenStmt *ws);
+bool collect_file_decls(CheckerContext *ctx, Array<Ast *> const &decls);
+bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstWhenStmt *ws);
-bool collect_when_stmt_from_file(CheckerContext *ctx, AstNodeWhenStmt *ws) {
+bool collect_when_stmt_from_file(CheckerContext *ctx, AstWhenStmt *ws) {
Operand operand = {Addressing_Invalid};
if (!ws->is_cond_determined) {
check_expr(ctx, &operand, ws->cond);
@@ -2708,16 +2708,16 @@ bool collect_when_stmt_from_file(CheckerContext *ctx, AstNodeWhenStmt *ws) {
ws->determined_cond = operand.value.kind == ExactValue_Bool && operand.value.value_bool;
}
- if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) {
+ if (ws->body == nullptr || ws->body->kind != Ast_BlockStmt) {
error(ws->cond, "Invalid body for 'when' statement");
} else {
if (ws->determined_cond) {
return collect_checked_packages_from_decl_list(ctx->checker, ws->body->BlockStmt.stmts);
} else if (ws->else_stmt) {
switch (ws->else_stmt->kind) {
- case AstNode_BlockStmt:
+ case Ast_BlockStmt:
return collect_checked_packages_from_decl_list(ctx->checker, ws->else_stmt->BlockStmt.stmts);
- case AstNode_WhenStmt:
+ case Ast_WhenStmt:
return collect_when_stmt_from_file(ctx, &ws->else_stmt->WhenStmt);
default:
error(ws->else_stmt, "Invalid 'else' statement in 'when' statement");
@@ -2729,7 +2729,7 @@ bool collect_when_stmt_from_file(CheckerContext *ctx, AstNodeWhenStmt *ws) {
return false;
}
-bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstNodeWhenStmt *ws) {
+bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstWhenStmt *ws) {
Operand operand = {Addressing_Invalid};
if (!ws->is_cond_determined) {
check_expr(ctx, &operand, ws->cond);
@@ -2744,16 +2744,16 @@ bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstNodeWhenStmt *ws)
ws->determined_cond = operand.value.kind == ExactValue_Bool && operand.value.value_bool;
}
- if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) {
+ if (ws->body == nullptr || ws->body->kind != Ast_BlockStmt) {
error(ws->cond, "Invalid body for 'when' statement");
} else {
if (ws->determined_cond) {
return collect_file_decls(ctx, ws->body->BlockStmt.stmts);
} else if (ws->else_stmt) {
switch (ws->else_stmt->kind) {
- case AstNode_BlockStmt:
+ case Ast_BlockStmt:
return collect_file_decls(ctx, ws->else_stmt->BlockStmt.stmts);
- case AstNode_WhenStmt:
+ case Ast_WhenStmt:
return collect_file_decls_from_when_stmt(ctx, &ws->else_stmt->WhenStmt);
default:
error(ws->else_stmt, "Invalid 'else' statement in 'when' statement");
@@ -2765,7 +2765,7 @@ bool collect_file_decls_from_when_stmt(CheckerContext *ctx, AstNodeWhenStmt *ws)
return false;
}
-bool collect_file_decls(CheckerContext *ctx, Array<AstNode *> const &decls) {
+bool collect_file_decls(CheckerContext *ctx, Array<Ast *> const &decls) {
GB_ASSERT(ctx->scope->is_file);
if (collect_checked_packages_from_decl_list(ctx->checker, decls)) {
@@ -2773,7 +2773,7 @@ bool collect_file_decls(CheckerContext *ctx, Array<AstNode *> const &decls) {
}
for_array(i, decls) {
- AstNode *decl = decls[i];
+ Ast *decl = decls[i];
switch (decl->kind) {
case_ast_node(vd, ValueDecl, decl);
check_collect_value_decl(ctx, decl);
@@ -2814,7 +2814,7 @@ bool collect_file_decls(CheckerContext *ctx, Array<AstNode *> const &decls) {
case_end;
case_ast_node(ce, CallExpr, decl);
- if (ce->proc->kind == AstNode_BasicDirective) {
+ if (ce->proc->kind == Ast_BasicDirective) {
Operand o = {};
check_expr(ctx, &o, decl);
}
@@ -2975,11 +2975,11 @@ void check_import_entities(Checker *c) {
add_curr_ast_file(&ctx, f);
for_array(j, f->scope->delayed_imports) {
- AstNode *decl = f->scope->delayed_imports[j];
+ Ast *decl = f->scope->delayed_imports[j];
check_add_import_decl(&ctx, decl);
}
for_array(j, f->scope->delayed_directives) {
- AstNode *expr = f->scope->delayed_directives[j];
+ Ast *expr = f->scope->delayed_directives[j];
Operand o = {};
check_expr(&ctx, &o, expr);
}
@@ -3139,7 +3139,7 @@ void check_proc_info(Checker *c, ProcInfo pi) {
if (pt->is_polymorphic && !pt->is_poly_specialized) {
Token token = pi.token;
if (pi.poly_def_node != nullptr) {
- token = ast_node_token(pi.poly_def_node);
+ token = ast_token(pi.poly_def_node);
}
error(token, "Unspecialized polymorphic procedure '%.*s'", LIT(name));
return;
@@ -3260,7 +3260,7 @@ void check_parsed_files(Checker *c) {
for_array(i, c->info.untyped.entries) {
auto *entry = &c->info.untyped.entries[i];
HashKey key = entry->key;
- AstNode *expr = cast(AstNode *)key.ptr;
+ Ast *expr = cast(Ast *)key.ptr;
ExprInfo *info = &entry->value;
if (info != nullptr && expr != nullptr) {
if (is_type_typed(info->type)) {
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-16 02:14:33 +0000