From dffa7916075abb7770fcf655b1d9306385b4e748 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sun, 12 Nov 2017 19:00:48 +0000 Subject: [PATCH] In error messages, remove ` with '; Fix error messages for `switch` --- src/check_decl.cpp | 64 +++---- src/check_expr.cpp | 400 ++++++++++++++++++++++---------------------- src/check_stmt.cpp | 188 ++++++++++----------- src/check_type.cpp | 94 +++++------ src/checker.cpp | 134 +++++++-------- src/exact_value.cpp | 4 +- src/ir.cpp | 48 +++--- src/main.cpp | 40 ++--- src/parser.cpp | 122 +++++++------- 9 files changed, 547 insertions(+), 547 deletions(-) diff --git a/src/check_decl.cpp b/src/check_decl.cpp index 940e9cc3b..72c8dcd0d 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -1,7 +1,7 @@ bool check_is_terminating(AstNode *node); void check_stmt (Checker *c, AstNode *node, u32 flags); -// NOTE(bill): `content_name` is for debugging and error messages +// NOTE(bill): 'content_name' is for debugging and error messages Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String context_name) { if (operand->mode == Addressing_Invalid || operand->type == t_invalid || @@ -13,7 +13,7 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex // TODO(bill): is this a good enough error message? // TODO(bill): Actually allow built in procedures to be passed around and thus be created on use error(operand->expr, - "Cannot assign built-in procedure `%s` in %.*s", + "Cannot assign built-in procedure '%s' in %.*s", expr_str, LIT(context_name)); @@ -25,7 +25,7 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex if (operand->mode == Addressing_Overload) { if (e->type == nullptr) { - error(operand->expr, "Cannot determine type from overloaded procedure `%.*s`", LIT(operand->overload_entities[0]->token.string)); + error(operand->expr, "Cannot determine type from overloaded procedure '%.*s'", LIT(operand->overload_entities[0]->token.string)); } else { check_assignment(c, operand, e->type, str_lit("variable assignment")); if (operand->mode != Addressing_Type) { @@ -62,13 +62,13 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex if (is_type_polymorphic(t)) { gbString str = type_to_string(t); defer (gb_string_free(str)); - error(e->token, "Invalid use of a polymorphic type `%s` in %.*s", str, LIT(context_name)); + error(e->token, "Invalid use of a polymorphic type '%s' in %.*s", str, LIT(context_name)); e->type = t_invalid; return nullptr; } else if (is_type_empty_union(t)) { gbString str = type_to_string(t); defer (gb_string_free(str)); - error(e->token, "An empty union `%s` cannot be instantiated in %.*s", str, LIT(context_name)); + error(e->token, "An empty union '%s' cannot be instantiated in %.*s", str, LIT(context_name)); e->type = t_invalid; return nullptr; } @@ -122,7 +122,7 @@ void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, Array 0 && lhs_count != rhs_count) { - error(lhs[0]->token, "Assignment count mismatch `%td` = `%td`", lhs_count, rhs_count); + error(lhs[0]->token, "Assignment count mismatch '%td' = '%td'", lhs_count, rhs_count); } } @@ -139,7 +139,7 @@ void check_init_constant(Checker *c, Entity *e, Operand *operand) { if (operand->mode != Addressing_Constant) { // TODO(bill): better error gbString str = expr_to_string(operand->expr); - error(operand->expr, "`%s` is not a constant", str); + error(operand->expr, "'%s' is not a constant", str); gb_string_free(str); if (e->type == nullptr) { e->type = t_invalid; @@ -148,7 +148,7 @@ void check_init_constant(Checker *c, Entity *e, Operand *operand) { } if (!is_type_constant_type(operand->type)) { gbString type_str = type_to_string(operand->type); - error(operand->expr, "Invalid constant type: `%s`", type_str); + error(operand->expr, "Invalid constant type: '%s'", type_str); gb_string_free(type_str); if (e->type == nullptr) { e->type = t_invalid; @@ -211,7 +211,7 @@ void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def, bool e->TypeName.is_type_alias = true; } else { gbString str = type_to_string(bt); - error(type_expr, "Type alias declaration with a non-named type `%s`", str); + error(type_expr, "Type alias declaration with a non-named type '%s'", str); gb_string_free(str); } } @@ -231,7 +231,7 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, Type *t = check_type(c, type_expr); if (!is_type_constant_type(t)) { gbString str = type_to_string(t); - error(type_expr, "Invalid constant type `%s`", str); + error(type_expr, "Invalid constant type '%s'", str); gb_string_free(str); e->type = t_invalid; return; @@ -324,7 +324,7 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, if (operand.mode == Addressing_Invalid || base_type(operand.type) == t_invalid) { gbString str = expr_to_string(init); - error(e->token, "Invalid declaration type `%s`", str); + error(e->token, "Invalid declaration type '%s'", str); gb_string_free(str); } @@ -415,12 +415,12 @@ void init_entity_foreign_library(Checker *c, Entity *e) { Entity *found = scope_lookup_entity(c->context.scope, name); if (found == nullptr) { if (is_blank_ident(name)) { - error(ident, "`_` cannot be used as a value type"); + error(ident, "'_' cannot be used as a value type"); } else { error(ident, "Undeclared name: %.*s", LIT(name)); } } else if (found->kind != Entity_LibraryName) { - error(ident, "`%.*s` cannot be used as a library name", LIT(name)); + error(ident, "'%.*s' cannot be used as a library name", LIT(name)); } else { // TODO(bill): Extra stuff to do with library names? *foreign_library = found; @@ -432,7 +432,7 @@ void init_entity_foreign_library(Checker *c, Entity *e) { String handle_link_name(Checker *c, 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"); + 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); @@ -491,17 +491,17 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { if (pt->param_count != 0 || pt->result_count != 0) { gbString str = type_to_string(proc_type); - error(e->token, "Procedure type of `main` was expected to be `proc()`, got %s", str); + error(e->token, "Procedure type of 'main' was expected to be 'proc()', got %s", str); gb_string_free(str); } if (pt->calling_convention != ProcCC_Odin && pt->calling_convention != ProcCC_Contextless) { - error(e->token, "Procedure `main` cannot have a custom calling convention"); + error(e->token, "Procedure 'main' cannot have a custom calling convention"); } pt->calling_convention = ProcCC_Contextless; if (d->scope->is_init) { if (c->info.entry_point != nullptr) { - error(e->token, "Redeclaration of the entry pointer procedure `main`"); + error(e->token, "Redeclaration of the entry pointer procedure 'main'"); } else { c->info.entry_point = e; } @@ -509,7 +509,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { } if (is_foreign && is_export) { - error(pl->type, "A foreign procedure cannot have an `export` tag"); + error(pl->type, "A foreign procedure cannot have an 'export' tag"); } if (pt->is_polymorphic) { @@ -528,7 +528,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { error(pl->body, "A foreign procedure cannot have a body"); } if (proc_type->Proc.c_vararg) { - error(pl->body, "A procedure with a `#c_vararg` field cannot have a body and must be foreign"); + error(pl->body, "A procedure with a '#c_vararg' field cannot have a body and must be foreign"); } d->scope = c->context.scope; @@ -546,7 +546,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { } if (pt->result_count == 0 && is_require_results) { - error(pl->type, "`#require_results` is not needed on a procedure with no results"); + error(pl->type, "'#require_results' is not needed on a procedure with no results"); } else { pt->require_results = is_require_results; } @@ -576,18 +576,18 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { if (is_type_proc(this_type) && is_type_proc(other_type)) { if (!are_signatures_similar_enough(this_type, other_type)) { error(d->proc_lit, - "Redeclaration of foreign procedure `%.*s` with different type signatures\n" + "Redeclaration of foreign procedure '%.*s' with different type signatures\n" "\tat %.*s(%td:%td)", LIT(name), LIT(pos.file), pos.line, pos.column); } } else if (!are_types_identical(this_type, other_type)) { error(d->proc_lit, - "Foreign entity `%.*s` previously declared elsewhere with a different type\n" + "Foreign entity '%.*s' previously declared elsewhere with a different type\n" "\tat %.*s(%td:%td)", LIT(name), LIT(pos.file), pos.line, pos.column); } } else if (name == "main") { - error(d->proc_lit, "The link name `main` is reserved for internal use"); + error(d->proc_lit, "The link name 'main' is reserved for internal use"); } else { map_set(fp, key, e); } @@ -605,11 +605,11 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { TokenPos pos = f->token.pos; // TODO(bill): Better error message? error(d->proc_lit, - "Non unique linking name for procedure `%.*s`\n" + "Non unique linking name for procedure '%.*s'\n" "\tother at %.*s(%td:%td)", LIT(name), LIT(pos.file), pos.line, pos.column); } else if (name == "main") { - error(d->proc_lit, "The link name `main` is reserved for internal use"); + error(d->proc_lit, "The link name 'main' is reserved for internal use"); } else { map_set(fp, key, e); } @@ -647,12 +647,12 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count if (is_type_polymorphic(base_type(e->type))) { gbString str = type_to_string(e->type); defer (gb_string_free(str)); - error(e->token, "Invalid use of a polymorphic type `%s` in %.*s", str, LIT(context_name)); + error(e->token, "Invalid use of a polymorphic type '%s' in %.*s", str, LIT(context_name)); e->type = t_invalid; } else if (is_type_empty_union(e->type)) { gbString str = type_to_string(e->type); defer (gb_string_free(str)); - error(e->token, "An empty union `%s` cannot be instantiated in %.*s", str, LIT(context_name)); + error(e->token, "An empty union '%s' cannot be instantiated in %.*s", str, LIT(context_name)); e->type = t_invalid; } } @@ -683,7 +683,7 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count Type *other_type = base_type(f->type); if (!are_types_identical(this_type, other_type)) { error(e->token, - "Foreign entity `%.*s` previously declared elsewhere with a different type\n" + "Foreign entity '%.*s' previously declared elsewhere with a different type\n" "\tat %.*s(%td:%td)", LIT(name), LIT(pos.file), pos.line, pos.column); } @@ -720,7 +720,7 @@ void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) { e->type = t_invalid; set_base_type(named_type, t_invalid); return; - // GB_PANIC("`%.*s` should been declared!", LIT(e->token.string)); + // GB_PANIC("'%.*s' should been declared!", LIT(e->token.string)); } } @@ -801,13 +801,13 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod uvar->Variable.is_immutable = is_immutable; Entity *prev = scope_insert_entity(c->context.scope, uvar); if (prev != nullptr) { - error(e->token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string)); + error(e->token, "Namespace collision while 'using' '%.*s' of: %.*s", LIT(name), LIT(prev->token.string)); break; } } } } else { - error(e->token, "`using` can only be applied to variables of type struct"); + error(e->token, "'using' can only be applied to variables of type struct"); break; } } @@ -820,7 +820,7 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod if (type->Proc.result_count > 0) { if (!check_is_terminating(body)) { if (token.kind == Token_Ident) { - error(bs->close, "Missing return statement at the end of the procedure `%.*s`", LIT(token.string)); + error(bs->close, "Missing return statement at the end of the procedure '%.*s'", LIT(token.string)); } else { error(bs->close, "Missing return statement at the end of the procedure"); } diff --git a/src/check_expr.cpp b/src/check_expr.cpp index a19522746..1ed657ec8 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -85,7 +85,7 @@ Type * check_init_variable (Checker *c, Entity *e, Operand *operand void error_operand_not_expression(Operand *o) { if (o->mode == Addressing_Type) { gbString err = expr_to_string(o->expr); - error(o->expr, "`%s` is not an expression but a type", err); + error(o->expr, "'%s' is not an expression but a type", err); gb_string_free(err); o->mode = Addressing_Invalid; } @@ -96,9 +96,9 @@ void error_operand_no_value(Operand *o) { gbString err = expr_to_string(o->expr); AstNode *x = unparen_expr(o->expr); if (x->kind == AstNode_CallExpr) { - error(o->expr, "`%s` call does not return a value and cannot be used as a value", err); + error(o->expr, "'%s' call does not return a value and cannot be used as a value", err); } else { - error(o->expr, "`%s` used as a value", err); + error(o->expr, "'%s' used as a value", err); } gb_string_free(err); o->mode = Addressing_Invalid; @@ -440,7 +440,7 @@ i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) { } if (is_type_untyped(src)) { if (is_type_any(dst)) { - // NOTE(bill): Anything can cast to `Any` + // NOTE(bill): Anything can cast to 'Any' add_type_info_type(c, s); return 10; } @@ -581,7 +581,7 @@ i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) { if (is_type_any(dst)) { if (!is_type_polymorphic(src)) { - // NOTE(bill): Anything can cast to `Any` + // NOTE(bill): Anything can cast to 'Any' add_type_info_type(c, s); return 10; } @@ -617,7 +617,7 @@ bool check_is_assignable_to(Checker *c, Operand *operand, Type *type) { } -// NOTE(bill): `content_name` is for debugging and error messages +// NOTE(bill): 'content_name' is for debugging and error messages void check_assignment(Checker *c, Operand *operand, Type *type, String context_name) { check_not_tuple(c, operand); if (operand->mode == Addressing_Invalid) { @@ -707,7 +707,7 @@ void check_assignment(Checker *c, Operand *operand, Type *type, String context_n // TODO(bill): is this a good enough error message? error(operand->expr, - "Cannot assign overloaded procedure `%s` to `%s` in %.*s", + "Cannot assign overloaded procedure '%s' to '%s' in %.*s", expr_str, op_type_str, LIT(context_name)); @@ -729,20 +729,20 @@ void check_assignment(Checker *c, Operand *operand, Type *type, String context_n case Addressing_Builtin: // TODO(bill): Actually allow built in procedures to be passed around and thus be created on use error(operand->expr, - "Cannot assign built-in procedure `%s` in %.*s", + "Cannot assign built-in procedure '%s' in %.*s", expr_str, LIT(context_name)); break; case Addressing_Type: error(operand->expr, - "Cannot assign `%s` which is a type in %.*s", + "Cannot assign '%s' which is a type in %.*s", op_type_str, LIT(context_name)); break; default: // TODO(bill): is this a good enough error message? error(operand->expr, - "Cannot assign value `%s` of type `%s` to `%s` in %.*s", + "Cannot assign value '%s' of type '%s' to '%s' in %.*s", expr_str, op_type_str, type_str, @@ -958,7 +958,7 @@ Entity *check_ident(Checker *c, Operand *o, AstNode *n, Type *named_type, Type * Entity *e = scope_lookup_entity(c->context.scope, name); if (e == nullptr) { if (is_blank_ident(name)) { - error(n, "`_` cannot be used as a value type"); + error(n, "'_' cannot be used as a value type"); } else { error(n, "Undeclared name: %.*s", LIT(name)); } @@ -1095,11 +1095,11 @@ Entity *check_ident(Checker *c, Operand *o, AstNode *n, Type *named_type, Type * case Entity_ImportName: if (!allow_import_name) { - error(n, "Use of import `%.*s` not in selector", LIT(name)); + error(n, "Use of import '%.*s' not in selector", LIT(name)); } return e; case Entity_LibraryName: - error(n, "Use of library `%.*s` not in foreign block", LIT(name)); + error(n, "Use of library '%.*s' not in foreign block", LIT(name)); return e; case Entity_Label: @@ -1123,7 +1123,7 @@ Entity *check_ident(Checker *c, Operand *o, AstNode *n, Type *named_type, Type * bool check_unary_op(Checker *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); + error(o->expr, "Expression has no value '%s'", str); gb_string_free(str); return false; } @@ -1135,27 +1135,27 @@ bool check_unary_op(Checker *c, Operand *o, Token op) { case Token_Sub: if (!is_type_numeric(type)) { str = expr_to_string(o->expr); - error(op, "Operator `%.*s` is not allowed with `%s`", LIT(op.string), str); + error(op, "Operator '%.*s' is not allowed with '%s'", LIT(op.string), str); gb_string_free(str); } break; case Token_Xor: if (!is_type_integer(type) && !is_type_boolean(type)) { - error(op, "Operator `%.*s` is only allowed with integers or booleans", LIT(op.string)); + error(op, "Operator '%.*s' is only allowed with integers or booleans", LIT(op.string)); } break; case Token_Not: if (!is_type_boolean(type)) { str = expr_to_string(o->expr); - error(op, "Operator `%.*s` is only allowed on boolean expression", LIT(op.string)); + error(op, "Operator '%.*s' is only allowed on boolean expression", LIT(op.string)); gb_string_free(str); } break; default: - error(op, "Unknown operator `%.*s`", LIT(op.string)); + error(op, "Unknown operator '%.*s'", LIT(op.string)); return false; } @@ -1169,7 +1169,7 @@ bool check_binary_op(Checker *c, Operand *o, Token op) { case Token_Sub: case Token_SubEq: if (!is_type_numeric(type) && !is_type_pointer(type)) { - error(op, "Operator `%.*s` is only allowed with numeric or pointer expressions", LIT(op.string)); + error(op, "Operator '%.*s' is only allowed with numeric or pointer expressions", LIT(op.string)); return false; } if (is_type_pointer(type)) { @@ -1177,7 +1177,7 @@ bool check_binary_op(Checker *c, Operand *o, Token op) { } if (base_type(type) == t_rawptr) { gbString str = type_to_string(type); - error(o->expr, "Invalid pointer type for pointer arithmetic: `%s`", str); + error(o->expr, "Invalid pointer type for pointer arithmetic: '%s'", str); gb_string_free(str); return false; } @@ -1189,7 +1189,7 @@ bool check_binary_op(Checker *c, Operand *o, Token op) { case Token_MulEq: case Token_QuoEq: if (!is_type_numeric(type)) { - error(op, "Operator `%.*s` is only allowed with numeric expressions", LIT(op.string)); + error(op, "Operator '%.*s' is only allowed with numeric expressions", LIT(op.string)); return false; } break; @@ -1202,7 +1202,7 @@ bool check_binary_op(Checker *c, Operand *o, Token op) { error(op, "String concatenation is only allowed with constant strings"); return false; } else if (!is_type_numeric(type)) { - error(op, "Operator `%.*s` is only allowed with numeric expressions", LIT(op.string)); + error(op, "Operator '%.*s' is only allowed with numeric expressions", LIT(op.string)); return false; } break; @@ -1214,7 +1214,7 @@ bool check_binary_op(Checker *c, Operand *o, Token op) { case Token_Xor: case Token_XorEq: if (!is_type_integer(type) && !is_type_boolean(type)) { - error(op, "Operator `%.*s` is only allowed with integers or booleans", LIT(op.string)); + error(op, "Operator '%.*s' is only allowed with integers or booleans", LIT(op.string)); return false; } break; @@ -1226,7 +1226,7 @@ bool check_binary_op(Checker *c, Operand *o, Token op) { case Token_ModModEq: case Token_AndNotEq: if (!is_type_integer(type)) { - error(op, "Operator `%.*s` is only allowed with integers", LIT(op.string)); + error(op, "Operator '%.*s' is only allowed with integers", LIT(op.string)); return false; } break; @@ -1236,13 +1236,13 @@ bool check_binary_op(Checker *c, Operand *o, Token op) { case Token_CmpAndEq: case Token_CmpOrEq: if (!is_type_boolean(type)) { - error(op, "Operator `%.*s` is only allowed with boolean expressions", LIT(op.string)); + error(op, "Operator '%.*s' is only allowed with boolean expressions", LIT(op.string)); return false; } break; default: - error(op, "Unknown operator `%.*s`", LIT(op.string)); + error(op, "Unknown operator '%.*s'", LIT(op.string)); return false; } @@ -1377,7 +1377,7 @@ void check_is_expressible(Checker *c, Operand *o, Type *type) { gbString b = type_to_string(type); if (is_type_numeric(o->type) && is_type_numeric(type)) { if (!is_type_integer(o->type) && is_type_integer(type)) { - error(o->expr, "`%s` truncated to `%s`", a, b); + error(o->expr, "'%s' truncated to '%s'", a, b); } else { char buf[127] = {}; String str = {}; @@ -1387,10 +1387,10 @@ void check_is_expressible(Checker *c, Operand *o, Type *type) { } else { str = i128_to_string(i, buf, gb_size_of(buf)); } - error(o->expr, "`%s = %.*s` overflows `%s`", a, LIT(str), b); + error(o->expr, "'%s = %.*s' overflows '%s'", a, LIT(str), b); } } else { - error(o->expr, "Cannot convert `%s` to `%s`", a, b); + error(o->expr, "Cannot convert '%s' to '%s'", a, b); } gb_string_free(b); @@ -1453,7 +1453,7 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) { if (ast_node_expect(node, AstNode_UnaryExpr)) { ast_node(ue, UnaryExpr, node); gbString str = expr_to_string(ue->expr); - error(op, "Cannot take the pointer address of `%s`", str); + error(op, "Cannot take the pointer address of '%s'", str); gb_string_free(str); } o->mode = Addressing_Invalid; @@ -1475,7 +1475,7 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) { if (!is_type_constant_type(o->type)) { gbString xt = type_to_string(o->type); gbString err_str = expr_to_string(node); - error(op, "Invalid type, `%s`, for constant unary expression `%s`", xt, err_str); + error(op, "Invalid type, '%s', for constant unary expression '%s'", xt, err_str); gb_string_free(err_str); gb_string_free(xt); o->mode = Addressing_Invalid; @@ -1489,7 +1489,7 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) { } if (op.kind == Token_Xor && is_type_untyped(type)) { gbString err_str = expr_to_string(node); - error(op, "Bitwise not cannot be applied to untyped constants `%s`", err_str); + error(op, "Bitwise not cannot be applied to untyped constants '%s'", err_str); gb_string_free(err_str); o->mode = Addressing_Invalid; return; @@ -1556,7 +1556,7 @@ void check_comparison(Checker *c, Operand *x, Operand *y, TokenKind op) { } gbString type_string = type_to_string(err_type); err_str = gb_string_make(c->tmp_allocator, - gb_bprintf("operator `%.*s` not defined for type `%s`", LIT(token_strings[op]), type_string)); + gb_bprintf("operator '%.*s' not defined for type '%s'", LIT(token_strings[op]), type_string)); gb_string_free(type_string); } } else { @@ -1572,7 +1572,7 @@ void check_comparison(Checker *c, Operand *x, Operand *y, TokenKind op) { yt = type_to_string(y->type); } err_str = gb_string_make(c->tmp_allocator, - gb_bprintf("mismatched types `%s` and `%s`", xt, yt)); + gb_bprintf("mismatched types '%s' and '%s'", xt, yt)); gb_string_free(yt); gb_string_free(xt); } @@ -1613,7 +1613,7 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { bool x_is_untyped = is_type_untyped(x->type); if (!(is_type_integer(x->type) || (x_is_untyped && x_val.kind == ExactValue_Integer))) { gbString err_str = expr_to_string(x->expr); - error(node, "Shifted operand `%s` must be an integer", err_str); + error(node, "Shifted operand '%s' must be an integer", err_str); gb_string_free(err_str); x->mode = Addressing_Invalid; return; @@ -1629,7 +1629,7 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { } } else { gbString err_str = expr_to_string(y->expr); - error(node, "Shift amount `%s` must be an unsigned integer", err_str); + error(node, "Shift amount '%s' must be an unsigned integer", err_str); gb_string_free(err_str); x->mode = Addressing_Invalid; return; @@ -1641,7 +1641,7 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { ExactValue y_val = exact_value_to_integer(y->value); if (y_val.kind != ExactValue_Integer) { gbString err_str = expr_to_string(y->expr); - error(node, "Shift amount `%s` must be an unsigned integer", err_str); + error(node, "Shift amount '%s' must be an unsigned integer", err_str); gb_string_free(err_str); x->mode = Addressing_Invalid; return; @@ -1650,7 +1650,7 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { i64 amount = i128_to_i64(y_val.value_integer); if (amount > 128) { gbString err_str = expr_to_string(y->expr); - error(node, "Shift amount too large: `%s`", err_str); + error(node, "Shift amount too large: '%s'", err_str); gb_string_free(err_str); x->mode = Addressing_Invalid; return; @@ -1684,13 +1684,13 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { if (y->mode == Addressing_Constant && i128_lt(y->value.value_integer, I128_ZERO)) { gbString err_str = expr_to_string(y->expr); - error(node, "Shift amount cannot be negative: `%s`", err_str); + error(node, "Shift amount cannot be negative: '%s'", err_str); gb_string_free(err_str); } if (!is_type_integer(x->type)) { gbString err_str = expr_to_string(y->expr); - error(node, "Shift operand `%s` must be an integer", err_str); + error(node, "Shift operand '%s' must be an integer", err_str); gb_string_free(err_str); x->mode = Addressing_Invalid; return; @@ -1714,7 +1714,7 @@ Operand check_ptr_addition(Checker *c, TokenKind op, Operand *ptr, Operand *offs if (base_type(ptr->type) == t_rawptr) { gbString str = type_to_string(ptr->type); - error(node, "Invalid pointer type for pointer arithmetic: `%s`", str); + error(node, "Invalid pointer type for pointer arithmetic: '%s'", str); gb_string_free(str); operand.mode = Addressing_Invalid; return operand; @@ -1726,7 +1726,7 @@ Operand check_ptr_addition(Checker *c, TokenKind op, Operand *ptr, Operand *offs if (elem_size <= 0) { gbString str = type_to_string(elem); - error(node, "Size of pointer's element type `%s` is zero and cannot be used for pointer arithmetic", str); + error(node, "Size of pointer's element type '%s' is zero and cannot be used for pointer arithmetic", str); gb_string_free(str); operand.mode = Addressing_Invalid; return operand; @@ -1815,7 +1815,7 @@ bool check_is_castable_to(Checker *c, Operand *operand, Type *y) { // NOTE(bill): This error should suppress the next casting error as it's at the same position gbString xs = type_to_string(x); gbString ys = type_to_string(y); - error(operand->expr, "Cannot cast from a union pointer `%s` to `%s`, try using `union_cast` or cast to a `rawptr`", xs, ys); + error(operand->expr, "Cannot cast from a union pointer '%s' to '%s', try using 'union_cast' or cast to a 'rawptr'", xs, ys); gb_string_free(ys); gb_string_free(xs); return false; @@ -1887,7 +1887,7 @@ void check_cast(Checker *c, Operand *x, Type *type) { gbString expr_str = expr_to_string(x->expr); gbString to_type = type_to_string(type); gbString from_type = type_to_string(x->type); - error(x->expr, "Cannot cast `%s` as `%s` from `%s`", expr_str, to_type, from_type); + error(x->expr, "Cannot cast '%s' as '%s' from '%s'", expr_str, to_type, from_type); gb_string_free(from_type); gb_string_free(to_type); gb_string_free(expr_str); @@ -1910,7 +1910,7 @@ void check_cast(Checker *c, Operand *x, Type *type) { bool check_transmute(Checker *c, AstNode *node, Operand *o, Type *t) { if (o->mode == Addressing_Constant) { gbString expr_str = expr_to_string(o->expr); - error(o->expr, "Cannot transmute a constant expression: `%s`", expr_str); + error(o->expr, "Cannot transmute a constant expression: '%s'", expr_str); gb_string_free(expr_str); o->mode = Addressing_Invalid; o->expr = node; @@ -1919,7 +1919,7 @@ bool check_transmute(Checker *c, AstNode *node, Operand *o, Type *t) { if (is_type_untyped(o->type)) { gbString expr_str = expr_to_string(o->expr); - error(o->expr, "Cannot transmute untyped expression: `%s`", expr_str); + error(o->expr, "Cannot transmute untyped expression: '%s'", expr_str); gb_string_free(expr_str); o->mode = Addressing_Invalid; o->expr = node; @@ -1931,7 +1931,7 @@ bool check_transmute(Checker *c, AstNode *node, Operand *o, Type *t) { if (srcz != dstz) { gbString expr_str = expr_to_string(o->expr); gbString type_str = type_to_string(t); - error(o->expr, "Cannot transmute `%s` to `%s`, %lld vs %lld bytes", expr_str, type_str, srcz, dstz); + error(o->expr, "Cannot transmute '%s' to '%s', %lld vs %lld bytes", expr_str, type_str, srcz, dstz); gb_string_free(type_str); gb_string_free(expr_str); o->mode = Addressing_Invalid; @@ -2015,7 +2015,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { if (op.kind == Token_Sub) { gbString lhs = expr_to_string(x->expr); gbString rhs = expr_to_string(y->expr); - error(node, "Invalid pointer arithmetic, did you mean `%s %.*s %s`?", rhs, LIT(op.string), lhs); + error(node, "Invalid pointer arithmetic, did you mean '%s %.*s %s'?", rhs, LIT(op.string), lhs); gb_string_free(rhs); gb_string_free(lhs); x->mode = Addressing_Invalid; @@ -2059,7 +2059,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { gbString xt = type_to_string(x->type); gbString yt = type_to_string(y->type); gbString expr_str = expr_to_string(x->expr); - error(op, "Mismatched types in binary expression `%s` : `%s` vs `%s`", expr_str, xt, yt); + error(op, "Mismatched types in binary expression '%s' : '%s' vs '%s'", expr_str, xt, yt); gb_string_free(expr_str); gb_string_free(yt); gb_string_free(xt); @@ -2121,7 +2121,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { if (!is_type_constant_type(type)) { gbString xt = type_to_string(x->type); gbString err_str = expr_to_string(node); - error(op, "Invalid type, `%s`, for constant binary expression `%s`", xt, err_str); + error(op, "Invalid type, '%s', for constant binary expression '%s'", xt, err_str); gb_string_free(err_str); gb_string_free(xt); x->mode = Addressing_Invalid; @@ -2161,7 +2161,7 @@ void update_expr_type(Checker *c, AstNode *e, Type *type, bool final) { switch (e->kind) { case_ast_node(ue, UnaryExpr, e); if (old.value.kind != ExactValue_Invalid) { - // NOTE(bill): if `e` is constant, the operands will be constant too. + // NOTE(bill): if 'e' is constant, the operands will be constant too. // They don't need to be updated as they will be updated later and // checked at the end of general checking stage. break; @@ -2226,11 +2226,11 @@ void convert_untyped_error(Checker *c, Operand *operand, Type *target_type) { if (i128_eq(operand->value.value_integer, I128_ZERO)) { if (make_string_c(expr_str) != "nil") { // HACK NOTE(bill): Just in case // NOTE(bill): Doesn't matter what the type is as it's still zero in the union - extra_text = " - Did you want `nil`?"; + extra_text = " - Did you want 'nil'?"; } } } - error(operand->expr, "Cannot convert `%s` to `%s`%s", expr_str, type_str, extra_text); + error(operand->expr, "Cannot convert '%s' to '%s'%s", expr_str, type_str, extra_text); gb_string_free(type_str); gb_string_free(expr_str); @@ -2400,7 +2400,7 @@ void convert_to_typed(Checker *c, Operand *operand, Type *target_type) { operand->mode = Addressing_Invalid; convert_untyped_error(c, operand, target_type); - gb_printf_err("Ambiguous type conversion to `%s`, which variant did you mean:\n\t", type_str); + gb_printf_err("Ambiguous type conversion to '%s', which variant did you mean:\n\t", type_str); i32 j = 0; for (i32 i = 0; i < valid_count; i++) { ValidIndexAndScore valid = valids[i]; @@ -2410,7 +2410,7 @@ void convert_to_typed(Checker *c, Operand *operand, Type *target_type) { gb_printf_err("or "); } gbString str = type_to_string(t->Union.variants[valid.index]); - gb_printf_err("`%s`", str); + gb_printf_err("'%s'", str); gb_string_free(str); j++; } @@ -2423,7 +2423,7 @@ void convert_to_typed(Checker *c, Operand *operand, Type *target_type) { operand->mode = Addressing_Invalid; convert_untyped_error(c, operand, target_type); if (count > 0) { - gb_printf_err("`%s` is a union which only excepts the following types:\n", type_str); + gb_printf_err("'%s' is a union which only excepts the following types:\n", type_str); gb_printf_err("\t"); for (i32 i = 0; i < count; i++) { Type *v = t->Union.variants[i]; @@ -2433,7 +2433,7 @@ void convert_to_typed(Checker *c, Operand *operand, Type *target_type) { gb_printf_err("or "); } gbString str = type_to_string(v); - gb_printf_err("`%s`", str); + gb_printf_err("'%s'", str); gb_string_free(str); } gb_printf_err("\n\n"); @@ -2478,7 +2478,7 @@ bool check_index_value(Checker *c, bool open_range, AstNode *index_value, i64 ma if (!is_type_integer(operand.type)) { gbString expr_str = expr_to_string(operand.expr); - error(operand.expr, "Index `%s` must be an integer", expr_str); + error(operand.expr, "Index '%s' must be an integer", expr_str); gb_string_free(expr_str); if (value) *value = 0; return false; @@ -2489,7 +2489,7 @@ bool check_index_value(Checker *c, bool open_range, AstNode *index_value, i64 ma i64 i = i128_to_i64(exact_value_to_integer(operand.value).value_integer); if (i < 0) { gbString expr_str = expr_to_string(operand.expr); - error(operand.expr, "Index `%s` cannot be a negative value", expr_str); + error(operand.expr, "Index '%s' cannot be a negative value", expr_str); gb_string_free(expr_str); if (value) *value = 0; return false; @@ -2505,7 +2505,7 @@ bool check_index_value(Checker *c, bool open_range, AstNode *index_value, i64 ma } if (out_of_bounds) { gbString expr_str = expr_to_string(operand.expr); - error(operand.expr, "Index `%s` is out of bounds range 0..<%lld", expr_str, max_count); + error(operand.expr, "Index '%s' is out of bounds range 0..<%lld", expr_str, max_count); gb_string_free(expr_str); return false; } @@ -2573,7 +2573,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h if (selector->kind != AstNode_Ident && selector->kind != AstNode_BasicLit) { // if (selector->kind != AstNode_Ident) { - error(selector, "Illegal selector kind: `%.*s`", LIT(ast_node_strings[selector->kind])); + error(selector, "Illegal selector kind: '%.*s'", LIT(ast_node_strings[selector->kind])); operand->mode = Addressing_Invalid; operand->expr = node; return nullptr; @@ -2615,7 +2615,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h } } if (!is_declared) { - error(op_expr, "`%.*s` is not declared by `%.*s`", LIT(entity_name), LIT(import_name)); + error(op_expr, "'%.*s' is not declared by '%.*s'", LIT(entity_name), LIT(import_name)); operand->mode = Addressing_Invalid; operand->expr = node; return nullptr; @@ -2699,7 +2699,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h if (is_not_exported) { gbString sel_str = expr_to_string(selector); - error(op_expr, "`%s` is not exported by `%.*s`", sel_str, LIT(import_name)); + error(op_expr, "'%s' is not exported by '%.*s'", sel_str, LIT(import_name)); gb_string_free(sel_str); operand->mode = Addressing_Invalid; operand->expr = node; @@ -2723,14 +2723,14 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h sel = lookup_field(c->allocator, operand->type, field_name, operand->mode == Addressing_Type); if (operand->mode != Addressing_Type && !check_is_field_exported(c, sel.entity)) { - error(op_expr, "`%.*s` is an unexported field", LIT(field_name)); + error(op_expr, "'%.*s' is an unexported field", LIT(field_name)); operand->mode = Addressing_Invalid; operand->expr = node; return nullptr; } entity = sel.entity; - // NOTE(bill): Add type info needed for fields like `names` + // NOTE(bill): Add type info needed for fields like 'names' if (entity != nullptr && (entity->flags&EntityFlag_TypeField)) { add_type_info_type(c, operand->type); } @@ -2797,7 +2797,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h gbString op_str = expr_to_string(op_expr); gbString type_str = type_to_string(operand->type); gbString sel_str = expr_to_string(selector); - error(op_expr, "`%s` of type `%s` has no field `%s`", op_str, type_str, sel_str); + error(op_expr, "'%s' of type '%s' has no field '%s'", op_str, type_str, sel_str); gb_string_free(sel_str); gb_string_free(type_str); gb_string_free(op_str); @@ -2810,7 +2810,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h gbString op_str = expr_to_string(op_expr); gbString type_str = type_to_string(operand->type); gbString sel_str = expr_to_string(selector); - error(op_expr, "Cannot access non-constant field `%s` from `%s`", sel_str, op_str); + error(op_expr, "Cannot access non-constant field '%s' from '%s'", sel_str, op_str); gb_string_free(sel_str); gb_string_free(type_str); gb_string_free(op_str); @@ -2875,7 +2875,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (err != nullptr) { gbString expr = expr_to_string(ce->proc); - error(ce->close, "%s arguments for `%s`, expected %td, got %td", + error(ce->close, "%s arguments for '%s', expected %td, got %td", err, expr, bp->arg_count, ce->args.count); gb_string_free(expr); @@ -2885,7 +2885,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (ce->args.count > 0) { if (ce->args[0]->kind == AstNode_FieldValue) { - error(call, "`field = value` calling is not allowed on built-in procedures"); + error(call, "'field = value' calling is not allowed on built-in procedures"); return false; } } @@ -2893,7 +2893,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id bool vari_expand = (ce->ellipsis.pos.line != 0); // if (vari_expand && id != BuiltinProc_append) { - // error(ce->ellipsis, "Invalid use of `...` with built-in procedure `append`"); + // error(ce->ellipsis, "Invalid use of '...' with built-in procedure 'append'"); // return false; // } @@ -2924,7 +2924,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id String name = bd->name; GB_ASSERT(name == "location"); if (ce->args.count > 1) { - error(ce->args[0], "`#location` expects either 0 or 1 arguments, got %td", ce->args.count); + error(ce->args[0], "'#location' expects either 0 or 1 arguments, got %td", ce->args.count); } if (ce->args.count > 0) { AstNode *arg = ce->args[0]; @@ -2936,7 +2936,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id e = check_selector(c, &o, arg, nullptr); } if (e == nullptr) { - error(ce->args[0], "`#location` expected a valid entity name"); + error(ce->args[0], "'#location' expected a valid entity name"); } } @@ -2985,7 +2985,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (mode == Addressing_Invalid) { String name = builtin_procs[id].name; gbString t = type_to_string(operand->type); - error(call, "`%.*s` is not supported for `%s`", LIT(name), t); + error(call, "'%.*s' is not supported for '%s'", LIT(name), t); return false; } @@ -3003,7 +3003,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id check_expr_or_type(c, &op, ce->args[0]); Type *type = op.type; if ((op.mode != Addressing_Type && type == nullptr) || type == t_invalid) { - error(ce->args[0], "Expected a type for `new`"); + error(ce->args[0], "Expected a type for 'new'"); return false; } operand->mode = Addressing_Value; @@ -3020,13 +3020,13 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id check_expr_or_type(c, &op, ce->args[0]); Type *type = op.type; if ((op.mode != Addressing_Type && type == nullptr) || type == t_invalid) { - error(ce->args[0], "Expected a type for `new_slice`"); + error(ce->args[0], "Expected a type for 'new_slice'"); return false; } isize arg_count = ce->args.count; if (arg_count < 2 || 3 < arg_count) { - error(ce->args[0], "`new_slice` expects 2 or 3 arguments, found %td", arg_count); + error(ce->args[0], "'new_slice' expects 2 or 3 arguments, found %td", arg_count); // NOTE(bill): Return the correct type to reduce errors } else { // If any are constant @@ -3042,7 +3042,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } if (size_count == 2 && sizes[0] > sizes[1]) { - error(ce->args[1], "`new_slice` count and capacity are swapped"); + error(ce->args[1], "'new_slice' count and capacity are swapped"); // No need quit } } @@ -3060,7 +3060,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id check_expr_or_type(c, &op, ce->args[0]); Type *type = op.type; if ((op.mode != Addressing_Type && type == nullptr) || type == t_invalid) { - error(ce->args[0], "Expected a type for `make`"); + error(ce->args[0], "Expected a type for 'make'"); return false; } @@ -3077,14 +3077,14 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id max_args = 3; } else { gbString str = type_to_string(type); - error(call, "Cannot `make` %s; type must be a slice, map, or dynamic array", str); + error(call, "Cannot 'make' %s; type must be a slice, map, or dynamic array", str); gb_string_free(str); return false; } isize arg_count = ce->args.count; if (arg_count < min_args || max_args < arg_count) { - error(ce->args[0], "`make` expects %td or %d argument, found %td", min_args, max_args, arg_count); + error(ce->args[0], "'make' expects %td or %d argument, found %td", min_args, max_args, arg_count); return false; } @@ -3101,7 +3101,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } if (size_count == 2 && sizes[0] > sizes[1]) { - error(ce->args[1], "`make` count and capacity are swapped"); + error(ce->args[1], "'make' count and capacity are swapped"); // No need quit } @@ -3133,7 +3133,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (!ok) { gbString type_str = type_to_string(type); - error(operand->expr, "Invalid type for `free`, got `%s`", type_str); + error(operand->expr, "Invalid type for 'free', got '%s'", type_str); gb_string_free(type_str); return false; } @@ -3153,7 +3153,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id Type *type = operand->type; if (!is_type_dynamic_array(type) && !is_type_dynamic_map(type)) { gbString str = type_to_string(type); - error(operand->expr, "Expected a dynamic array or dynamic map, got `%s`", str); + error(operand->expr, "Expected a dynamic array or dynamic map, got '%s'", str); gb_string_free(str); return false; } @@ -3166,7 +3166,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } Type *arg_type = base_type(op.type); if (!is_type_integer(arg_type)) { - error(operand->expr, "`reserve` capacities must be an integer"); + error(operand->expr, "'reserve' capacities must be an integer"); return false; } @@ -3183,7 +3183,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id type = base_type(type_deref(type)); if (!is_type_dynamic_array(type) && !is_type_map(type) && !is_type_slice(type)) { gbString str = type_to_string(type); - error(operand->expr, "Invalid type for `clear`, got `%s`", str); + error(operand->expr, "Invalid type for 'clear', got '%s'", str); gb_string_free(str); return false; } @@ -3205,7 +3205,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id type = base_type(type_deref(type)); if (!is_type_dynamic_array(type) && !is_type_slice(type)) { gbString str = type_to_string(type); - error(operand->expr, "Expected a slice or dynamic array, got `%s`", str); + error(operand->expr, "Expected a slice or dynamic array, got '%s'", str); gb_string_free(str); return false; } @@ -3215,7 +3215,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id is_addressable = true; } if (!is_addressable) { - error(operand->expr, "`append` can only operate on addressable values"); + error(operand->expr, "'append' can only operate on addressable values"); return false; } @@ -3251,7 +3251,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id Type *type = operand->type; if (!is_type_map(type)) { gbString str = type_to_string(type); - error(operand->expr, "Expected a map, got `%s`", str); + error(operand->expr, "Expected a map, got '%s'", str); gb_string_free(str); return false; } @@ -3268,7 +3268,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (!check_is_assignable_to(c, &op, key)) { gbString kt = type_to_string(key); gbString ot = type_to_string(op.type); - error(operand->expr, "Expected a key of type `%s`, got `%s`", key, ot); + error(operand->expr, "Expected a key of type '%s', got '%s'", key, ot); gb_string_free(ot); gb_string_free(kt); return false; @@ -3290,7 +3290,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } Type *t = o.type; if (t == nullptr || t == t_invalid) { - error(ce->args[0], "Invalid argument for `size_of`"); + error(ce->args[0], "Invalid argument for 'size_of'"); return false; } t = default_type(t); @@ -3311,7 +3311,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } Type *t = o.type; if (t == nullptr || t == t_invalid) { - error(ce->args[0], "Invalid argument for `align_of`"); + error(ce->args[0], "Invalid argument for 'align_of'"); return false; } t = default_type(t); @@ -3330,7 +3330,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id Type *bt = check_type(c, ce->args[0]); Type *type = base_type(bt); if (type == nullptr || type == t_invalid) { - error(ce->args[0], "Expected a type for `offset_of`"); + error(ce->args[0], "Expected a type for 'offset_of'"); return false; } @@ -3341,7 +3341,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return false; } if (is_type_array(type) || is_type_vector(type)) { - error(field_arg, "Invalid type for `offset_of`"); + error(field_arg, "Invalid type for 'offset_of'"); return false; } @@ -3351,14 +3351,14 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (sel.entity == nullptr) { gbString type_str = type_to_string(bt); error(ce->args[0], - "`%s` has no field named `%.*s`", type_str, LIT(arg->token.string)); + "'%s' has no field named '%.*s'", type_str, LIT(arg->token.string)); gb_string_free(type_str); return false; } if (sel.indirect) { gbString type_str = type_to_string(bt); error(ce->args[0], - "Field `%.*s` is embedded via a pointer in `%s`", LIT(arg->token.string), type_str); + "Field '%.*s' is embedded via a pointer in '%s'", LIT(arg->token.string), type_str); gb_string_free(type_str); return false; } @@ -3373,16 +3373,16 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case BuiltinProc_type_of: // proc type_of(val: Type) -> type(Type) - check_assignment(c, operand, nullptr, str_lit("argument of `type_of`")); + check_assignment(c, operand, nullptr, str_lit("argument of 'type_of'")); if (operand->mode == Addressing_Invalid || operand->mode == Addressing_Builtin) { return false; } if (operand->type == nullptr || operand->type == t_invalid) { - error(operand->expr, "Invalid argument to `type_of`"); + error(operand->expr, "Invalid argument to 'type_of'"); return false; } if (is_type_polymorphic(operand->type)) { - error(operand->expr, "`type_of` of polymorphic type cannot be determined"); + error(operand->expr, "'type_of' of polymorphic type cannot be determined"); return false; } operand->mode = Addressing_Type; @@ -3392,7 +3392,7 @@ 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) { - compiler_error("`type_info_of` Cannot be declared within a #shared_global_scope due to how the internals of the compiler works"); + 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 @@ -3405,7 +3405,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } Type *t = o.type; if (t == nullptr || t == t_invalid || is_type_polymorphic(operand->type)) { - error(ce->args[0], "Invalid argument for `type_info_of`"); + error(ce->args[0], "Invalid argument for 'type_info_of'"); return false; } t = default_type(t); @@ -3423,13 +3423,13 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (!is_type_boolean(operand->type) && operand->mode != Addressing_Constant) { gbString str = expr_to_string(ce->args[0]); - error(call, "`%s` is not a constant boolean", str); + error(call, "'%s' is not a constant boolean", str); gb_string_free(str); return false; } if (!operand->value.value_bool) { gbString str = expr_to_string(ce->args[0]); - error(call, "Compile time assertion: `%s`", str); + error(call, "Compile time assertion: '%s'", str); gb_string_free(str); } @@ -3444,7 +3444,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (!is_type_vector(type) && !is_type_array(type)) { gbString type_str = type_to_string(operand->type); error(call, - "You can only `swizzle` a vector or array, got `%s`", + "You can only 'swizzle' a vector or array, got '%s'", type_str); gb_string_free(type_str); return false; @@ -3476,17 +3476,17 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } Type *arg_type = base_type(op.type); if (!is_type_integer(arg_type) || op.mode != Addressing_Constant) { - error(op.expr, "Indices to `swizzle` must be constant integers"); + error(op.expr, "Indices to 'swizzle' must be constant integers"); return false; } if (op.value.value_integer < I128_ZERO) { - error(op.expr, "Negative `swizzle` index"); + error(op.expr, "Negative 'swizzle' index"); return false; } if (max_count128 <= op.value.value_integer) { - error(op.expr, "`swizzle` index exceeds length"); + error(op.expr, "'swizzle' index exceeds length"); return false; } @@ -3494,7 +3494,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } if (arg_count > max_count) { - error(call, "Too many `swizzle` indices, %td > %td", arg_count, max_count); + error(call, "Too many 'swizzle' indices, %td > %td", arg_count, max_count); return false; } @@ -3540,7 +3540,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (!are_types_identical(x.type, y.type)) { gbString tx = type_to_string(x.type); gbString ty = type_to_string(y.type); - error(call, "Mismatched types to `complex`, `%s` vs `%s`", tx, ty); + error(call, "Mismatched types to 'complex', '%s' vs '%s'", tx, ty); gb_string_free(ty); gb_string_free(tx); return false; @@ -3548,7 +3548,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (!is_type_float(x.type)) { gbString s = type_to_string(x.type); - error(call, "Arguments have type `%s`, expected a floating point", s); + error(call, "Arguments have type '%s', expected a floating point", s); gb_string_free(s); return false; } @@ -3593,7 +3593,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (!is_type_complex(x->type)) { gbString s = type_to_string(x->type); - error(call, "Argument has type `%s`, expected a complex type", s); + error(call, "Argument has type '%s', expected a complex type", s); gb_string_free(s); return false; } @@ -3633,7 +3633,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } } else { gbString s = type_to_string(x->type); - error(call, "Expected a complex or quaternion, got `%s`", s); + error(call, "Expected a complex or quaternion, got '%s'", s); gb_string_free(s); return false; } @@ -3650,19 +3650,19 @@ break; Type *ptr_type = base_type(operand->type); if (!is_type_pointer(ptr_type)) { gbString type_str = type_to_string(operand->type); - error(call, "Expected a pointer to `slice_ptr`, got `%s`", type_str); + error(call, "Expected a pointer to 'slice_ptr', got '%s'", type_str); gb_string_free(type_str); return false; } if (ptr_type == t_rawptr) { - error(call, "`rawptr` cannot have pointer arithmetic"); + error(call, "'rawptr' cannot have pointer arithmetic"); return false; } isize arg_count = ce->args.count; if (arg_count < 2 || 3 < arg_count) { - error(ce->args[0], "`slice_ptr` expects 2 or 3 arguments, found %td", arg_count); + error(ce->args[0], "'slice_ptr' expects 2 or 3 arguments, found %td", arg_count); // NOTE(bill): Return the correct type to reduce errors } else { // If any are constant @@ -3678,7 +3678,7 @@ break; } if (size_count == 2 && sizes[0] > sizes[1]) { - error(ce->args[1], "`slice_ptr` count and capacity are swapped"); + error(ce->args[1], "'slice_ptr' count and capacity are swapped"); // No need quit } } @@ -3693,7 +3693,7 @@ break; Type *slice_type = base_type(operand->type); if (!is_type_slice(slice_type)) { gbString type_str = type_to_string(operand->type); - error(call, "Expected a slice type, got `%s`", type_str); + error(call, "Expected a slice type, got '%s'", type_str); gb_string_free(type_str); return false; } @@ -3709,7 +3709,7 @@ break; if (!is_type_struct(type) & !is_type_union(type)) { gbString type_str = type_to_string(operand->type); - error(call, "Expected a struct or union type, got `%s`", type_str); + error(call, "Expected a struct or union type, got '%s'", type_str); gb_string_free(type_str); return false; } @@ -3732,7 +3732,7 @@ break; Type *type = base_type(operand->type); if (!is_type_ordered(type) || !(is_type_numeric(type) || is_type_string(type))) { gbString type_str = type_to_string(operand->type); - error(call, "Expected a ordered numeric type to `min`, got `%s`", type_str); + error(call, "Expected a ordered numeric type to 'min', got '%s'", type_str); gb_string_free(type_str); return false; } @@ -3747,7 +3747,7 @@ break; if (!is_type_ordered(b.type) || !(is_type_numeric(b.type) || is_type_string(b.type))) { gbString type_str = type_to_string(b.type); error(call, - "Expected a ordered numeric type to `min`, got `%s`", + "Expected a ordered numeric type to 'min', got '%s'", type_str); gb_string_free(type_str); return false; @@ -3783,7 +3783,7 @@ break; gbString type_a = type_to_string(a.type); gbString type_b = type_to_string(b.type); error(call, - "Mismatched types to `min`, `%s` vs `%s`", + "Mismatched types to 'min', '%s' vs '%s'", type_a, type_b); gb_string_free(type_b); gb_string_free(type_a); @@ -3801,7 +3801,7 @@ break; if (!is_type_ordered(type) || !(is_type_numeric(type) || is_type_string(type))) { gbString type_str = type_to_string(operand->type); error(call, - "Expected a ordered numeric or string type to `max`, got `%s`", + "Expected a ordered numeric or string type to 'max', got '%s'", type_str); gb_string_free(type_str); return false; @@ -3817,7 +3817,7 @@ break; if (!is_type_ordered(b.type) || !(is_type_numeric(b.type) || is_type_string(b.type))) { gbString type_str = type_to_string(b.type); error(call, - "Expected a ordered numeric or string type to `max`, got `%s`", + "Expected a ordered numeric or string type to 'max', got '%s'", type_str); gb_string_free(type_str); return false; @@ -3853,7 +3853,7 @@ break; gbString type_a = type_to_string(a.type); gbString type_b = type_to_string(b.type); error(call, - "Mismatched types to `max`, `%s` vs `%s`", + "Mismatched types to 'max', '%s' vs '%s'", type_a, type_b); gb_string_free(type_b); gb_string_free(type_a); @@ -3869,7 +3869,7 @@ break; // proc abs(n: numeric) -> numeric if (!is_type_numeric(operand->type) && !is_type_vector(operand->type)) { gbString type_str = type_to_string(operand->type); - error(call, "Expected a numeric type to `abs`, got `%s`", type_str); + error(call, "Expected a numeric type to 'abs', got '%s'", type_str); gb_string_free(type_str); return false; } @@ -3910,7 +3910,7 @@ break; Type *type = base_type(operand->type); if (!is_type_ordered(type) || !(is_type_numeric(type) || is_type_string(type))) { gbString type_str = type_to_string(operand->type); - error(call, "Expected a ordered numeric or string type to `clamp`, got `%s`", type_str); + error(call, "Expected a ordered numeric or string type to 'clamp', got '%s'", type_str); gb_string_free(type_str); return false; } @@ -3927,7 +3927,7 @@ break; } if (!is_type_ordered(y.type) || !(is_type_numeric(y.type) || is_type_string(y.type))) { gbString type_str = type_to_string(y.type); - error(call, "Expected a ordered numeric or string type to `clamp`, got `%s`", type_str); + error(call, "Expected a ordered numeric or string type to 'clamp', got '%s'", type_str); gb_string_free(type_str); return false; } @@ -3938,7 +3938,7 @@ break; } if (!is_type_ordered(z.type) || !(is_type_numeric(z.type) || is_type_string(z.type))) { gbString type_str = type_to_string(z.type); - error(call, "Expected a ordered numeric or string type to `clamp`, got `%s`", type_str); + error(call, "Expected a ordered numeric or string type to 'clamp', got '%s'", type_str); gb_string_free(type_str); return false; } @@ -3983,7 +3983,7 @@ break; gbString type_y = type_to_string(y.type); gbString type_z = type_to_string(z.type); error(call, - "Mismatched types to `clamp`, `%s`, `%s`, `%s`", + "Mismatched types to 'clamp', '%s', '%s', '%s'", type_x, type_y, type_z); gb_string_free(type_z); gb_string_free(type_y); @@ -4001,7 +4001,7 @@ break; check_expr_or_type(c, &op, ce->args[0]); Type *t = op.type; if ((op.mode != Addressing_Type && t == nullptr) || t == t_invalid) { - error(ce->args[0], "Expected a type for `transmute`"); + error(ce->args[0], "Expected a type for 'transmute'"); return false; } AstNode *expr = ce->args[1]; @@ -4013,7 +4013,7 @@ break; if (o->mode == Addressing_Constant) { gbString expr_str = expr_to_string(o->expr); - error(o->expr, "Cannot transmute a constant expression: `%s`", expr_str); + error(o->expr, "Cannot transmute a constant expression: '%s'", expr_str); gb_string_free(expr_str); o->mode = Addressing_Invalid; o->expr = expr; @@ -4022,7 +4022,7 @@ break; if (is_type_untyped(o->type)) { gbString expr_str = expr_to_string(o->expr); - error(o->expr, "Cannot transmute untyped expression: `%s`", expr_str); + error(o->expr, "Cannot transmute untyped expression: '%s'", expr_str); gb_string_free(expr_str); o->mode = Addressing_Invalid; o->expr = expr; @@ -4034,7 +4034,7 @@ break; if (srcz != dstz) { gbString expr_str = expr_to_string(o->expr); gbString type_str = type_to_string(t); - error(o->expr, "Cannot transmute `%s` to `%s`, %lld vs %lld bytes", expr_str, type_str, srcz, dstz); + error(o->expr, "Cannot transmute '%s' to '%s', %lld vs %lld bytes", expr_str, type_str, srcz, dstz); gb_string_free(type_str); gb_string_free(expr_str); o->mode = Addressing_Invalid; @@ -4060,7 +4060,7 @@ isize add_dependencies_from_unpacking(Checker *c, Entity **lhs, isize lhs_count, Entity *e = lhs[tuple_index + j]; DeclInfo *decl = decl_info_of_entity(&c->info, e); if (decl != nullptr) { - c->context.decl = decl; // will be reset by the `defer` any way + c->context.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? @@ -4203,14 +4203,14 @@ CALL_ARGUMENT_CHECKER(check_call_arguments_internal) { if (vari_expand && !variadic) { if (show_error) { error(ce->ellipsis, - "Cannot use `...` in call to a non-variadic procedure: `%.*s`", + "Cannot use '...' in call to a non-variadic procedure: '%.*s'", LIT(ce->proc->Ident.token.string)); } err = CallArgumentError_NonVariadicExpand; } else if (vari_expand && pt->c_vararg) { if (show_error) { error(ce->ellipsis, - "Cannot use `...` in call to a `#c_vararg` variadic procedure: `%.*s`", + "Cannot use '...' in call to a '#c_vararg' variadic procedure: '%.*s'", LIT(ce->proc->Ident.token.string)); } err = CallArgumentError_NonVariadicExpand; @@ -4225,10 +4225,10 @@ CALL_ARGUMENT_CHECKER(check_call_arguments_internal) { } if (error_code != 0) { err = CallArgumentError_TooManyArguments; - char *err_fmt = "Too many arguments for `%s`, expected %td arguments"; + char *err_fmt = "Too many arguments for '%s', expected %td arguments"; if (error_code < 0) { err = CallArgumentError_TooFewArguments; - err_fmt = "Too few arguments for `%s`, expected %td arguments"; + err_fmt = "Too few arguments for '%s', expected %td arguments"; } if (show_error) { @@ -4265,7 +4265,7 @@ CALL_ARGUMENT_CHECKER(check_call_arguments_internal) { continue; } else if (o.mode != Addressing_Type) { if (show_error) { - error(o.expr, "Expected a type for the argument `%.*s`", LIT(e->token.string)); + error(o.expr, "Expected a type for the argument '%.*s'", LIT(e->token.string)); } err = CallArgumentError_WrongTypes; } @@ -4303,7 +4303,7 @@ CALL_ARGUMENT_CHECKER(check_call_arguments_internal) { t = slice; if (operand_index != param_count) { if (show_error) { - error(o.expr, "`...` in a variadic procedure can only have one variadic argument at the end"); + error(o.expr, "'...' in a variadic procedure can only have one variadic argument at the end"); } if (data) { data->score = score; @@ -4397,7 +4397,7 @@ CALL_ARGUMENT_CHECKER(check_named_call_arguments) { if (fv->field->kind != AstNode_Ident) { if (show_error) { gbString expr_str = expr_to_string(fv->field); - error(arg, "Invalid parameter name `%s` in procedure call", expr_str); + error(arg, "Invalid parameter name '%s' in procedure call", expr_str); gb_string_free(expr_str); } err = CallArgumentError_InvalidFieldValue; @@ -4407,14 +4407,14 @@ CALL_ARGUMENT_CHECKER(check_named_call_arguments) { isize index = lookup_procedure_parameter(pt, name); if (index < 0) { if (show_error) { - error(arg, "No parameter named `%.*s` for this procedure type", LIT(name)); + error(arg, "No parameter named '%.*s' for this procedure type", LIT(name)); } err = CallArgumentError_ParameterNotFound; continue; } if (visited[index]) { if (show_error) { - error(arg, "Duplicate parameter `%.*s` in procedure call", LIT(name)); + error(arg, "Duplicate parameter '%.*s' in procedure call", LIT(name)); } err = CallArgumentError_DuplicateParameter; continue; @@ -4447,13 +4447,13 @@ CALL_ARGUMENT_CHECKER(check_named_call_arguments) { if (show_error) { if (e->kind == Entity_TypeName) { - error(call, "Type parameter `%.*s` is missing in procedure call", + error(call, "Type parameter '%.*s' is missing in procedure call", LIT(e->token.string)); } else if (e->kind == Entity_Constant && e->Constant.value.kind != ExactValue_Invalid) { // Ignore } else { gbString str = type_to_string(e->type); - error(call, "Parameter `%.*s` of type `%s` is missing in procedure call", + error(call, "Parameter '%.*s' of type '%s' is missing in procedure call", LIT(e->token.string), str); gb_string_free(str); } @@ -4485,7 +4485,7 @@ CALL_ARGUMENT_CHECKER(check_named_call_arguments) { GB_ASSERT(pt->is_polymorphic); if (o->mode != Addressing_Type) { if (show_error) { - error(o->expr, "Expected a type for the argument `%.*s`", LIT(e->token.string)); + error(o->expr, "Expected a type for the argument '%.*s'", LIT(e->token.string)); } err = CallArgumentError_WrongTypes; } @@ -4537,7 +4537,7 @@ CallArgumentData check_call_arguments(Checker *c, Operand *operand, Type *proc_t bool vari_expand = (ce->ellipsis.pos.line != 0); if (vari_expand) { - // error(ce->ellipsis, "Invalid use of `...` with `field = value` call`"); + // error(ce->ellipsis, "Invalid use of '...' with 'field = value' call'"); } } else { @@ -4605,7 +4605,7 @@ CallArgumentData check_call_arguments(Checker *c, Operand *operand, Type *proc_t if (valid_count == 0) { - error(operand->expr, "No overloads or ambiguous call for `%.*s` that match with the given arguments", LIT(name)); + error(operand->expr, "No overloads or ambiguous call for '%.*s' that match with the given arguments", LIT(name)); gb_printf_err("\tGiven argument types -> ("); for_array(i, operands) { Operand o = operands[i]; @@ -4640,7 +4640,7 @@ CallArgumentData check_call_arguments(Checker *c, Operand *operand, Type *proc_t } result_type = t_invalid; } else if (valid_count > 1) { - error(operand->expr, "Ambiguous procedure call `%.*s` tha match with the given arguments", LIT(name)); + error(operand->expr, "Ambiguous procedure call '%.*s' tha match with the given arguments", LIT(name)); gb_printf_err("\tGiven argument types -> ("); for_array(i, operands) { Operand o = operands[i]; @@ -4777,7 +4777,7 @@ CallArgumentError check_polymorphic_struct_type(Checker *c, Operand *operand, As bool vari_expand = (ce->ellipsis.pos.line != 0); if (vari_expand) { - error(ce->ellipsis, "Invalid use of `...` in a polymorphic type call`"); + error(ce->ellipsis, "Invalid use of '...' in a polymorphic type call'"); } } else { @@ -4802,7 +4802,7 @@ CallArgumentError check_polymorphic_struct_type(Checker *c, Operand *operand, As if (fv->field->kind != AstNode_Ident) { if (show_error) { gbString expr_str = expr_to_string(fv->field); - error(arg, "Invalid parameter name `%s` in polymorphic type call", expr_str); + error(arg, "Invalid parameter name '%s' in polymorphic type call", expr_str); gb_string_free(expr_str); } err = CallArgumentError_InvalidFieldValue; @@ -4812,14 +4812,14 @@ CallArgumentError check_polymorphic_struct_type(Checker *c, Operand *operand, As isize index = lookup_polymorphic_struct_parameter(st, name); if (index < 0) { if (show_error) { - error(arg, "No parameter named `%.*s` for this polymorphic type", LIT(name)); + error(arg, "No parameter named '%.*s' for this polymorphic type", LIT(name)); } err = CallArgumentError_ParameterNotFound; continue; } if (visited[index]) { if (show_error) { - error(arg, "Duplicate parameter `%.*s` in polymorphic type", LIT(name)); + error(arg, "Duplicate parameter '%.*s' in polymorphic type", LIT(name)); } err = CallArgumentError_DuplicateParameter; continue; @@ -4838,11 +4838,11 @@ CallArgumentError check_polymorphic_struct_type(Checker *c, Operand *operand, As if (show_error) { if (e->kind == Entity_TypeName) { - error(call, "Type parameter `%.*s` is missing in polymorphic type call", + error(call, "Type parameter '%.*s' is missing in polymorphic type call", LIT(e->token.string)); } else { gbString str = type_to_string(e->type); - error(call, "Parameter `%.*s` of type `%s` is missing in polymorphic type call", + error(call, "Parameter '%.*s' of type '%s' is missing in polymorphic type call", LIT(e->token.string), str); gb_string_free(str); } @@ -4868,7 +4868,7 @@ CallArgumentError check_polymorphic_struct_type(Checker *c, Operand *operand, As if (e->kind == Entity_TypeName) { if (o->mode != Addressing_Type) { if (show_error) { - error(o->expr, "Expected a type for the argument `%.*s`", LIT(e->token.string)); + error(o->expr, "Expected a type for the argument '%.*s'", LIT(e->token.string)); } err = CallArgumentError_WrongTypes; } @@ -4967,7 +4967,7 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { mix = arg->kind == AstNode_FieldValue; } if (mix) { - error(arg, "Mixture of `field = value` and value elements in a procedure all is not allowed"); + error(arg, "Mixture of 'field = value' and value elements in a procedure all is not allowed"); fail = true; } } @@ -5017,12 +5017,12 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { operand->mode = Addressing_Invalid; isize arg_count = ce->args.count; switch (arg_count) { - case 0: error(call, "Missing argument in conversion to `%s`", str); break; - default: error(call, "Too many arguments in conversion to `%s`", str); break; + case 0: error(call, "Missing argument in conversion to '%s'", str); break; + default: error(call, "Too many arguments in conversion to '%s'", str); break; case 1: { AstNode *arg = ce->args[0]; if (arg->kind == AstNode_FieldValue) { - error(call, "`field = value` cannot be used in a type conversion"); + error(call, "'field = value' cannot be used in a type conversion"); arg = arg->FieldValue.value; // NOTE(bill): Carry on the cast regardless } @@ -5055,7 +5055,7 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { AstNode *e = operand->expr; gbString str = expr_to_string(e); gbString type_str = type_to_string(operand->type); - error(e, "Cannot call a non-procedure: `%s` of type `%s`", str, type_str); + error(e, "Cannot call a non-procedure: '%s' of type '%s'", str, type_str); gb_string_free(type_str); gb_string_free(str); @@ -5120,7 +5120,7 @@ void check_expr_with_type_hint(Checker *c, Operand *o, AstNode *e, Type *t) { } if (err_str != nullptr) { gbString str = expr_to_string(e); - error(e, "`%s` %s", str, err_str); + error(e, "'%s' %s", str, err_str); gb_string_free(str); o->mode = Addressing_Invalid; } @@ -5212,7 +5212,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t switch (i->kind) { case Token_context: if (c->context.proc_name.len == 0) { - error(node, "`context` is only allowed within procedures"); + error(node, "'context' is only allowed within procedures"); return kind; } @@ -5243,7 +5243,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t break; default: - error(node, "Illegal implicit name `%.*s`", LIT(i->string)); + error(node, "Illegal implicit name '%.*s'", LIT(i->string)); return kind; } case_end; @@ -5326,7 +5326,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t check_procedure_type(c, type, pl->type); if (!is_type_proc(type)) { gbString str = expr_to_string(node); - error(node, "Invalid procedure literal `%s`", str); + error(node, "Invalid procedure literal '%s'", str); gb_string_free(str); check_close_scope(c); return kind; @@ -5456,7 +5456,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t Type *t = base_type(type); if (is_type_polymorphic(t)) { gbString str = type_to_string(type); - error(node, "Cannot use a polymorphic type for a compound literal, got `%s`", str); + error(node, "Cannot use a polymorphic type for a compound literal, got '%s'", str); o->expr = node; o->type = type; gb_string_free(str); @@ -5475,7 +5475,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t if (!is_type_struct(t)) { if (cl->elems.count != 0) { gbString type_str = type_to_string(type); - error(node, "Illegal compound literal type `%s`", type_str); + error(node, "Illegal compound literal type '%s'", type_str); gb_string_free(type_str); } break; @@ -5504,13 +5504,13 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t for_array(i, cl->elems) { AstNode *elem = cl->elems[i]; if (elem->kind != AstNode_FieldValue) { - error(elem, "Mixture of `field = value` and value elements in a literal is not allowed"); + error(elem, "Mixture of 'field = value' and value elements in a literal is not allowed"); continue; } ast_node(fv, FieldValue, elem); if (fv->field->kind != AstNode_Ident) { gbString expr_str = expr_to_string(fv->field); - error(elem, "Invalid field name `%s` in structure literal", expr_str); + error(elem, "Invalid field name '%s' in structure literal", expr_str); gb_string_free(expr_str); continue; } @@ -5519,17 +5519,17 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t Selection sel = lookup_field(c->allocator, type, name, o->mode == Addressing_Type); bool is_unknown = sel.entity == nullptr; if (is_unknown) { - error(elem, "Unknown field `%.*s` in structure literal", LIT(name)); + error(elem, "Unknown field '%.*s' in structure literal", LIT(name)); continue; } if (!is_unknown && !check_is_field_exported(c, sel.entity)) { - error(elem, "Cannot assign to an unexported field `%.*s` in structure literal", LIT(name)); + error(elem, "Cannot assign to an unexported field '%.*s' in structure literal", LIT(name)); continue; } if (sel.index.count > 1) { - error(elem, "Cannot assign to an anonymous field `%.*s` in a structure literal (at the moment)", LIT(name)); + error(elem, "Cannot assign to an anonymous field '%.*s' in a structure literal (at the moment)", LIT(name)); continue; } @@ -5537,7 +5537,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t add_entity_use(c, fv->field, field); if (fields_visited[sel.index[0]]) { - error(elem, "Duplicate field `%.*s` in structure literal", LIT(name)); + error(elem, "Duplicate field '%.*s' in structure literal", LIT(name)); continue; } @@ -5571,10 +5571,10 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t AstNode *elem = cl->elems[index]; if (elem->kind == AstNode_FieldValue) { seen_field_value = true; - // error(elem, "Mixture of `field = value` and value elements in a literal is not allowed"); + // error(elem, "Mixture of 'field = value' and value elements in a literal is not allowed"); // continue; } else if (seen_field_value) { - error(elem, "Value elements cannot be used after a `field = value`"); + error(elem, "Value elements cannot be used after a 'field = value'"); continue; } if (index >= field_count) { @@ -5594,7 +5594,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t if (!check_is_field_exported(c, field)) { gbString t = type_to_string(type); - error(o->expr, "Implicit assignment to an unexported field `%.*s` in `%s` literal", + error(o->expr, "Implicit assignment to an unexported field '%.*s' in '%s' literal", LIT(field->token.string), t); gb_string_free(t); continue; @@ -5669,7 +5669,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t } if (e->kind == AstNode_FieldValue) { - error(e, "`field = value` is only allowed in struct literals"); + error(e, "'field = value' is only allowed in struct literals"); continue; } @@ -5721,13 +5721,13 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t for_array(i, cl->elems) { AstNode *elem = cl->elems[i]; if (elem->kind != AstNode_FieldValue) { - error(elem, "Mixture of `field = value` and value elements in a `any` literal is not allowed"); + error(elem, "Mixture of 'field = value' and value elements in a 'any' literal is not allowed"); continue; } ast_node(fv, FieldValue, elem); if (fv->field->kind != AstNode_Ident) { gbString expr_str = expr_to_string(fv->field); - error(elem, "Invalid field name `%s` in `any` literal", expr_str); + error(elem, "Invalid field name '%s' in 'any' literal", expr_str); gb_string_free(expr_str); continue; } @@ -5735,47 +5735,47 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t Selection sel = lookup_field(c->allocator, type, name, o->mode == Addressing_Type); if (sel.entity == nullptr) { - error(elem, "Unknown field `%.*s` in `any` literal", LIT(name)); + error(elem, "Unknown field '%.*s' in 'any' literal", LIT(name)); continue; } isize index = sel.index[0]; if (fields_visited[index]) { - error(elem, "Duplicate field `%.*s` in `any` literal", LIT(name)); + error(elem, "Duplicate field '%.*s' in 'any' literal", LIT(name)); continue; } fields_visited[index] = true; check_expr(c, o, fv->value); - // NOTE(bill): `any` literals can never be constant + // NOTE(bill): 'any' literals can never be constant is_constant = false; - check_assignment(c, o, field_types[index], str_lit("`any` literal")); + check_assignment(c, o, field_types[index], str_lit("'any' literal")); } } else { for_array(index, cl->elems) { AstNode *elem = cl->elems[index]; if (elem->kind == AstNode_FieldValue) { - error(elem, "Mixture of `field = value` and value elements in a `any` literal is not allowed"); + error(elem, "Mixture of 'field = value' and value elements in a 'any' literal is not allowed"); continue; } check_expr(c, o, elem); if (index >= field_count) { - error(o->expr, "Too many values in `any` literal, expected %td", field_count); + error(o->expr, "Too many values in 'any' literal, expected %td", field_count); break; } - // NOTE(bill): `any` literals can never be constant + // NOTE(bill): 'any' literals can never be constant is_constant = false; - check_assignment(c, o, field_types[index], str_lit("`any` literal")); + check_assignment(c, o, field_types[index], str_lit("'any' literal")); } if (cl->elems.count < field_count) { - error(cl->close, "Too few values in `any` literal, expected %td, got %td", field_count, cl->elems.count); + error(cl->close, "Too few values in 'any' literal, expected %td, got %td", field_count, cl->elems.count); } } } @@ -5792,7 +5792,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t for_array(i, cl->elems) { AstNode *elem = cl->elems[i]; if (elem->kind != AstNode_FieldValue) { - error(elem, "Only `field = value` elements are allowed in a map literal"); + error(elem, "Only 'field = value' elements are allowed in a map literal"); continue; } ast_node(fv, FieldValue, elem); @@ -5816,7 +5816,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t } gbString str = type_to_string(type); - error(node, "Invalid compound literal type `%s`", str); + error(node, "Invalid compound literal type '%s'", str); gb_string_free(str); return kind; } @@ -5861,7 +5861,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t if (o->mode == Addressing_Constant) { gbString expr_str = expr_to_string(o->expr); - error(o->expr, "A type assertion cannot be applied to a constant expression: `%s`", expr_str); + error(o->expr, "A type assertion cannot be applied to a constant expression: '%s'", expr_str); gb_string_free(expr_str); o->mode = Addressing_Invalid; o->expr = node; @@ -5870,7 +5870,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t if (is_type_untyped(o->type)) { gbString expr_str = expr_to_string(o->expr); - error(o->expr, "A type assertion cannot be applied to an untyped expression: `%s`", expr_str); + error(o->expr, "A type assertion cannot be applied to an untyped expression: '%s'", expr_str); gb_string_free(expr_str); o->mode = Addressing_Invalid; o->expr = node; @@ -5900,9 +5900,9 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t defer (gb_string_free(expr_str)); defer (gb_string_free(dst_type_str)); if (bsrc->Union.variants.count == 0) { - error(o->expr, "Cannot type assert `%s` to `%s` as this is an empty union", expr_str, dst_type_str); + error(o->expr, "Cannot type assert '%s' to '%s' as this is an empty union", expr_str, dst_type_str); } else { - error(o->expr, "Cannot type assert `%s` to `%s` as it is not a variant of that union", expr_str, dst_type_str); + error(o->expr, "Cannot type assert '%s' to '%s' as it is not a variant of that union", expr_str, dst_type_str); } o->mode = Addressing_Invalid; o->expr = node; @@ -5922,7 +5922,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t add_type_info_type(c, t); } else { gbString str = type_to_string(o->type); - error(o->expr, "Type assertions can only operate on unions and `any`, got %s", str); + error(o->expr, "Type assertions can only operate on unions and 'any', got %s", str); gb_string_free(str); o->mode = Addressing_Invalid; o->expr = node; @@ -6036,9 +6036,9 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t defer (gb_string_free(str)); defer (gb_string_free(type_str)); if (is_const) { - error(o->expr, "Cannot index a constant `%s`", str); + error(o->expr, "Cannot index a constant '%s'", str); } else { - error(o->expr, "Cannot index `%s` of type `%s`", str, type_str); + error(o->expr, "Cannot index '%s' of type '%s'", str, type_str); } o->mode = Addressing_Invalid; o->expr = node; @@ -6047,7 +6047,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t if (ie->index == nullptr) { gbString str = expr_to_string(o->expr); - error(o->expr, "Missing index for `%s`", str); + error(o->expr, "Missing index for '%s'", str); gb_string_free(str); o->mode = Addressing_Invalid; o->expr = node; @@ -6094,7 +6094,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t max_count = t->Array.count; if (o->mode != Addressing_Variable) { gbString str = expr_to_string(node); - error(node, "Cannot slice array `%s`, value is not addressable", str); + error(node, "Cannot slice array '%s', value is not addressable", str); gb_string_free(str); o->mode = Addressing_Invalid; o->expr = node; @@ -6116,7 +6116,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t if (!valid) { gbString str = expr_to_string(o->expr); - error(o->expr, "Cannot slice `%s`", str); + error(o->expr, "Cannot slice '%s'", str); gb_string_free(str); o->mode = Addressing_Invalid; o->expr = node; @@ -6206,7 +6206,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t } else { gbString str = expr_to_string(o->expr); gbString typ = type_to_string(o->type); - error(o->expr, "Cannot dereference `%s` of type `%s`", str, typ); + error(o->expr, "Cannot dereference '%s' of type '%s'", str, typ); gb_string_free(typ); gb_string_free(str); o->mode = Addressing_Invalid; diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 3c0714b77..c85ee5ea9 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -30,11 +30,11 @@ void check_stmt_list(Checker *c, Array stmts, u32 flags) { if (i+1 < max) { switch (n->kind) { case AstNode_ReturnStmt: - error(n, "Statements after this `return` are never executed"); + error(n, "Statements after this 'return' are never executed"); break; case AstNode_BranchStmt: - error(n, "Statements after this `%.*s` are never executed", LIT(n->BranchStmt.token.string)); + error(n, "Statements after this '%.*s' are never executed", LIT(n->BranchStmt.token.string)); break; } } @@ -93,9 +93,9 @@ bool check_has_break(AstNode *stmt, bool implicit) { -// NOTE(bill): The last expression has to be a `return` statement +// NOTE(bill): The last expression has to be a 'return' statement // TODO(bill): This is a mild hack and should be probably handled properly -// TODO(bill): Warn/err against code after `return` that it won't be executed +// TODO(bill): Warn/err against code after 'return' that it won't be executed bool check_is_terminating(AstNode *node) { switch (node->kind) { case_ast_node(rs, ReturnStmt, node); @@ -186,10 +186,10 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { AstNode *node = unparen_expr(lhs->expr); - // NOTE(bill): Ignore assignments to `_` + // NOTE(bill): Ignore assignments to '_' if (is_blank_ident(node)) { add_entity_definition(&c->info, node, nullptr); - check_assignment(c, rhs, nullptr, str_lit("assignment to `_` identifier")); + check_assignment(c, rhs, nullptr, str_lit("assignment to '_' identifier")); if (rhs->mode == Addressing_Invalid) { return nullptr; } @@ -280,7 +280,7 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { } gbString lhs_expr = expr_to_string(lhs->expr); gbString rhs_expr = expr_to_string(rhs->expr); - error(rhs->expr, "Cannot assign `%s` to bit field `%s`", rhs_expr, lhs_expr); + error(rhs->expr, "Cannot assign '%s' to bit field '%s'", rhs_expr, lhs_expr); gb_string_free(rhs_expr); gb_string_free(lhs_expr); return nullptr; @@ -297,7 +297,7 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { if (tav.mode != Addressing_Variable) { if (!is_type_pointer(tav.type)) { gbString str = expr_to_string(lhs->expr); - error(lhs->expr, "Cannot assign to the value of a map `%s`", str); + error(lhs->expr, "Cannot assign to the value of a map '%s'", str); gb_string_free(str); return nullptr; } @@ -315,7 +315,7 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { check_expr(c, &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); + error(lhs->expr, "Cannot assign to struct field '%s' in map", str); gb_string_free(str); return nullptr; } @@ -323,9 +323,9 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { gbString str = expr_to_string(lhs->expr); if (lhs->mode == Addressing_Immutable) { - error(lhs->expr, "Cannot assign to an immutable: `%s`", str); + error(lhs->expr, "Cannot assign to an immutable: '%s'", str); } else { - error(lhs->expr, "Cannot assign to `%s`", str); + error(lhs->expr, "Cannot assign to '%s'", str); } gb_string_free(str); @@ -341,21 +341,21 @@ Type *check_assignment_variable(Checker *c, Operand *lhs, Operand *rhs) { return rhs->type; } -enum MatchTypeKind { - MatchType_Invalid, - MatchType_Union, - MatchType_Any, +enum SwitchTypeKind { + SwitchType_Invalid, + SwitchType_Union, + SwitchType_Any, }; -MatchTypeKind check_valid_type_match_type(Type *type) { +SwitchTypeKind check_valid_type_switch_type(Type *type) { type = type_deref(type); if (is_type_union(type)) { - return MatchType_Union; + return SwitchType_Union; } if (is_type_any(type)) { - return MatchType_Any; + return SwitchType_Any; } - return MatchType_Invalid; + return SwitchType_Invalid; } void check_stmt_internal(Checker *c, AstNode *node, u32 flags); @@ -394,11 +394,11 @@ void check_when_stmt(Checker *c, AstNodeWhenStmt *ws, u32 flags) { Operand operand = {Addressing_Invalid}; check_expr(c, &operand, ws->cond); if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) { - error(ws->cond, "Non-constant boolean `when` condition"); + error(ws->cond, "Non-constant boolean 'when' condition"); return; } if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) { - error(ws->cond, "Invalid body for `when` statement"); + error(ws->cond, "Invalid body for 'when' statement"); return; } if (operand.value.kind == ExactValue_Bool && @@ -413,7 +413,7 @@ void check_when_stmt(Checker *c, AstNodeWhenStmt *ws, u32 flags) { check_when_stmt(c, &ws->else_stmt->WhenStmt, flags); break; default: - error(ws->else_stmt, "Invalid `else` statement in `when` statement"); + error(ws->else_stmt, "Invalid 'else' statement in 'when' statement"); break; } } @@ -445,7 +445,7 @@ void check_label(Checker *c, AstNode *label) { for_array(i, c->context.decl->labels) { BlockLabel bl = c->context.decl->labels[i]; if (bl.name == name) { - error(label, "Duplicate label with the name `%.*s`", LIT(name)); + error(label, "Duplicate label with the name '%.*s'", LIT(name)); ok = false; break; } @@ -461,10 +461,10 @@ void check_label(Checker *c, AstNode *label) { } } -// Returns `true` for `continue`, `false` for `return` +// Returns 'true' for 'continue', 'false' for 'return' bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bool is_selector, Entity *e) { if (e == nullptr) { - error(us->token, "`using` applied to an unknown entity"); + error(us->token, "'using' applied to an unknown entity"); return true; } @@ -481,14 +481,14 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo Entity *found = scope_insert_entity(c->context.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)); + error(us->token, "Namespace collision while 'using' '%s' of: %.*s", expr_str, LIT(found->token.string)); gb_string_free(expr_str); return false; } f->using_parent = e; } } else { - error(us->token, "`using` can be only applied to enum type entities"); + error(us->token, "'using' can be only applied to enum type entities"); } break; @@ -504,7 +504,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo if (found != nullptr) { gbString expr_str = expr_to_string(expr); error(us->token, - "Namespace collision while `using` `%s` of: %.*s\n" + "Namespace collision while 'using' '%s' of: %.*s\n" "\tat %.*s(%td:%td)\n" "\tat %.*s(%td:%td)", expr_str, LIT(found->token.string), @@ -534,14 +534,14 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo Entity *prev = scope_insert_entity(c->context.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)); + error(us->token, "Namespace collision while 'using' '%s' of: %.*s", expr_str, LIT(prev->token.string)); gb_string_free(expr_str); return false; } } } } else { - error(us->token, "`using` can only be applied to variables of type struct or raw_union"); + error(us->token, "'using' can only be applied to variables of type struct or raw_union"); return false; } @@ -549,28 +549,28 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo } case Entity_Constant: - error(us->token, "`using` cannot be applied to a constant"); + error(us->token, "'using' cannot be applied to a constant"); break; case Entity_Procedure: case Entity_Builtin: - error(us->token, "`using` cannot be applied to a procedure"); + error(us->token, "'using' cannot be applied to a procedure"); break; case Entity_Nil: - error(us->token, "`using` cannot be applied to `nil`"); + error(us->token, "'using' cannot be applied to 'nil'"); break; case Entity_Label: - error(us->token, "`using` cannot be applied to a label"); + error(us->token, "'using' cannot be applied to a label"); break; case Entity_Invalid: - error(us->token, "`using` cannot be applied to an invalid entity"); + error(us->token, "'using' cannot be applied to an invalid entity"); break; default: - GB_PANIC("TODO(bill): `using` other expressions?"); + GB_PANIC("TODO(bill): 'using' other expressions?"); } return true; @@ -589,7 +589,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { switch (operand.mode) { case Addressing_Type: { gbString str = type_to_string(operand.type); - error(node, "`%s` is not an expression", str); + error(node, "'%s' is not an expression", str); gb_string_free(str); break; @@ -606,14 +606,14 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (is_type_proc(t)) { if (t->Proc.require_results) { gbString expr_str = expr_to_string(ce->proc); - error(node, "`%s` requires that its results must be handled", expr_str); + error(node, "'%s' requires that its results must be handled", expr_str); gb_string_free(expr_str); } } return; } gbString expr_str = expr_to_string(operand.expr); - error(node, "Expression is not used: `%s`", expr_str); + error(node, "Expression is not used: '%s'", expr_str); gb_string_free(expr_str); break; @@ -717,7 +717,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_assignment_variable(c, &lhs_operands[i], &rhs_operands[i]); } if (lhs_count != rhs_count) { - error(as->lhs[0], "Assignment count mismatch `%td` = `%td`", lhs_count, rhs_count); + error(as->lhs[0], "Assignment count mismatch '%td' = '%td'", lhs_count, rhs_count); } break; } @@ -726,11 +726,11 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { // a += 1; // Single-sided Token op = as->op; if (as->lhs.count != 1 || as->rhs.count != 1) { - error(op, "Assignment operation `%.*s` requires single-valued expressions", LIT(op.string)); + error(op, "Assignment operation '%.*s' requires single-valued expressions", LIT(op.string)); return; } if (!gb_is_between(op.kind, Token__AssignOpBegin+1, Token__AssignOpEnd-1)) { - error(op, "Unknown Assignment operation `%.*s`", LIT(op.string)); + error(op, "Unknown Assignment operation '%.*s'", LIT(op.string)); return; } Operand lhs = {Addressing_Invalid}; @@ -772,7 +772,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Operand operand = {Addressing_Invalid}; check_expr(c, &operand, is->cond); if (operand.mode != Addressing_Invalid && !is_type_boolean(operand.type)) { - error(is->cond, "Non-boolean condition in `if` statement"); + error(is->cond, "Non-boolean condition in 'if' statement"); } check_stmt(c, is->body, mod_flags); @@ -784,7 +784,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_stmt(c, is->else_stmt, mod_flags); break; default: - error(is->else_stmt, "Invalid `else` statement in `if` statement"); + error(is->else_stmt, "Invalid 'else' statement in 'if' statement"); break; } } @@ -800,7 +800,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { GB_ASSERT(c->proc_stack.count > 0); if (c->context.in_defer) { - error(rs->token, "You cannot `return` within a defer statement"); + error(rs->token, "You cannot 'return' within a defer statement"); break; } @@ -817,7 +817,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { mix = arg->kind == AstNode_FieldValue; } if (mix) { - error(arg, "Mixture of `field = value` and value elements in a procedure all is not allowed"); + error(arg, "Mixture of 'field = value' and value elements in a procedure all is not allowed"); fail = true; } } @@ -876,18 +876,18 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { ast_node(fv, FieldValue, arg); if (fv->field->kind != AstNode_Ident) { gbString expr_str = expr_to_string(fv->field); - error(arg, "Invalid parameter name `%s` in return statement", expr_str); + error(arg, "Invalid parameter name '%s' in return statement", expr_str); gb_string_free(expr_str); continue; } String name = fv->field->Ident.token.string; isize index = lookup_procedure_result(pt, name); if (index < 0) { - error(arg, "No result named `%.*s` for this procedure type", LIT(name)); + error(arg, "No result named '%.*s' for this procedure type", LIT(name)); continue; } if (visited[index]) { - error(arg, "Duplicate result `%.*s` in return statement", LIT(name)); + error(arg, "Duplicate result '%.*s' in return statement", LIT(name)); continue; } @@ -913,7 +913,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } gbString str = type_to_string(e->type); - error(node, "Return value `%.*s` of type `%s` is missing in return statement", + error(node, "Return value '%.*s' of type '%s' is missing in return statement", LIT(e->token.string), str); gb_string_free(str); } @@ -956,7 +956,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Operand o = {Addressing_Invalid}; check_expr(c, &o, fs->cond); if (o.mode != Addressing_Invalid && !is_type_boolean(o.type)) { - error(fs->cond, "Non-boolean condition in `for` statement"); + error(fs->cond, "Non-boolean condition in 'for' statement"); } } if (fs->post != nullptr) { @@ -964,7 +964,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (fs->post->kind != AstNode_AssignStmt && fs->post->kind != AstNode_IncDecStmt) { - error(fs->post, "`for` statement post statement must be a simple statement"); + error(fs->post, "'for' statement post statement must be a simple statement"); } } check_stmt(c, fs->body, new_flags); @@ -1024,7 +1024,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { gbString xt = type_to_string(x.type); gbString yt = type_to_string(y.type); gbString expr_str = expr_to_string(x.expr); - error(ie->op, "Mismatched types in interval expression `%s` : `%s` vs `%s`", expr_str, xt, yt); + error(ie->op, "Mismatched types in interval expression '%s' : '%s' vs '%s'", expr_str, xt, yt); gb_string_free(expr_str); gb_string_free(yt); gb_string_free(xt); @@ -1078,7 +1078,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (operand.mode == Addressing_Type) { if (!is_type_enum(operand.type)) { gbString t = type_to_string(operand.type); - error(operand.expr, "Cannot iterate over the type `%s`", t); + error(operand.expr, "Cannot iterate over the type '%s'", t); gb_string_free(t); goto skip_expr; } else { @@ -1127,7 +1127,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (val == nullptr) { gbString s = expr_to_string(operand.expr); gbString t = type_to_string(operand.type); - error(operand.expr, "Cannot iterate over `%s` of type `%s`", s, t); + error(operand.expr, "Cannot iterate over '%s' of type '%s'", s, t); gb_string_free(t); gb_string_free(s); } @@ -1160,7 +1160,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } else { TokenPos pos = found->token.pos; error(token, - "Redeclaration of `%.*s` in this scope\n" + "Redeclaration of '%.*s' in this scope\n" "\tat %.*s(%td:%td)", LIT(str), LIT(pos.file), pos.line, pos.column); entity = found; @@ -1202,7 +1202,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } if (ss->tag != nullptr) { check_expr(c, &x, ss->tag); - check_assignment(c, &x, nullptr, str_lit("match expression")); + check_assignment(c, &x, nullptr, str_lit("switch expression")); } else { x.mode = Addressing_Constant; x.type = t_bool; @@ -1215,7 +1215,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } if (is_type_vector(x.type)) { gbString str = type_to_string(x.type); - error(x.expr, "Invalid match expression type: %s", str); + error(x.expr, "Invalid switch expression type: %s", str); gb_string_free(str); break; } @@ -1240,7 +1240,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (first_default != nullptr) { TokenPos pos = ast_node_token(first_default).pos; error(stmt, - "multiple `default` clauses\n" + "multiple default clauses\n" "\tfirst at %.*s(%td:%td)", LIT(pos.file), pos.line, pos.column); } else { @@ -1281,7 +1281,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (!is_type_ordered(x.type)) { gbString str = type_to_string(x.type); - error(x.expr, "Unordered type `%s`, is invalid for an interval expression", str); + error(x.expr, "Unordered type '%s', is invalid for an interval expression", str); gb_string_free(str); continue; } @@ -1359,7 +1359,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { TokenPos pos = tap.token.pos; gbString expr_str = expr_to_string(y.expr); error(y.expr, - "Duplicate case `%s`\n" + "Duplicate case '%s'\n" "\tprevious case at %.*s(%td:%td)", expr_str, LIT(pos.file), pos.line, pos.column); @@ -1401,32 +1401,32 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_open_scope(c, node); check_label(c, ss->label); // TODO(bill): What should the label's "scope" be? - MatchTypeKind match_type_kind = MatchType_Invalid; + SwitchTypeKind switch_type_kind = SwitchType_Invalid; if (ss->tag->kind != AstNode_AssignStmt) { - error(ss->tag, "Expected an `in` assignment for this type match statement"); + error(ss->tag, "Expected an 'in' assignment for this type switch statement"); break; } ast_node(as, AssignStmt, ss->tag); Token as_token = ast_node_token(ss->tag); if (as->lhs.count != 1) { - syntax_error(as_token, "Expected 1 name before `in`"); + syntax_error(as_token, "Expected 1 name before 'in'"); break; } if (as->rhs.count != 1) { - syntax_error(as_token, "Expected 1 expression after `in`"); + syntax_error(as_token, "Expected 1 expression after 'in'"); break; } AstNode *lhs = as->lhs[0]; AstNode *rhs = as->rhs[0]; check_expr(c, &x, rhs); - check_assignment(c, &x, nullptr, str_lit("type match expression")); - match_type_kind = check_valid_type_match_type(x.type); - if (check_valid_type_match_type(x.type) == MatchType_Invalid) { + check_assignment(c, &x, nullptr, str_lit("type switch expression")); + switch_type_kind = check_valid_type_switch_type(x.type); + if (check_valid_type_switch_type(x.type) == SwitchType_Invalid) { gbString str = type_to_string(x.type); - error(x.expr, "Invalid type for this type match expression, got `%s`", str); + error(x.expr, "Invalid type for this type switch expression, got '%s'", str); gb_string_free(str); break; } @@ -1452,7 +1452,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (first_default != nullptr) { TokenPos pos = ast_node_token(first_default).pos; error(stmt, - "Multiple `default` clauses\n" + "Multiple 'default' clauses\n" "\tfirst at %.*s(%td:%td)", LIT(pos.file), pos.line, pos.column); } else { first_default = default_stmt; @@ -1462,7 +1462,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (lhs->kind != AstNode_Ident) { - error(rhs, "Expected an identifier, got `%.*s`", LIT(ast_node_strings[rhs->kind])); + error(rhs, "Expected an identifier, got '%.*s'", LIT(ast_node_strings[rhs->kind])); break; } @@ -1488,7 +1488,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Operand y = {}; check_expr_or_type(c, &y, type_expr); - if (match_type_kind == MatchType_Union) { + if (switch_type_kind == SwitchType_Union) { GB_ASSERT(is_type_union(bt)); bool tag_type_found = false; for_array(i, bt->Union.variants) { @@ -1500,15 +1500,15 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } if (!tag_type_found) { gbString type_str = type_to_string(y.type); - error(y.expr, "Unknown tag type, got `%s`", type_str); + error(y.expr, "Unknown tag type, got '%s'", type_str); gb_string_free(type_str); continue; } case_type = y.type; - } else if (match_type_kind == MatchType_Any) { + } else if (switch_type_kind == SwitchType_Any) { case_type = y.type; } else { - GB_PANIC("Unknown type to type match statement"); + GB_PANIC("Unknown type to type switch statement"); } HashKey key = hash_type(y.type); @@ -1517,7 +1517,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { TokenPos pos = cc->token.pos; gbString expr_str = expr_to_string(y.expr); error(y.expr, - "Duplicate type case `%s`\n" + "Duplicate type case '%s'\n" "\tprevious type case at %.*s(%td:%td)", expr_str, LIT(pos.file), pos.line, pos.column); @@ -1577,21 +1577,21 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { switch (token.kind) { case Token_break: if ((flags & Stmt_BreakAllowed) == 0) { - error(token, "`break` only allowed in loops or `match` statements"); + error(token, "'break' only allowed in loops or 'switch' statements"); } break; case Token_continue: if ((flags & Stmt_ContinueAllowed) == 0) { - error(token, "`continue` only allowed in loops"); + error(token, "'continue' only allowed in loops"); } break; case Token_fallthrough: if ((flags & Stmt_FallthroughAllowed) == 0) { - error(token, "`fallthrough` statement in illegal position"); + error(token, "'fallthrough' statement in illegal position"); } break; default: - error(token, "Invalid AST: Branch Statement `%.*s`", LIT(token.string)); + error(token, "Invalid AST: Branch Statement '%.*s'", LIT(token.string)); break; } @@ -1610,7 +1610,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } add_entity_use(c, ident, e); if (e->kind != Entity_Label) { - error(ident, "`%.*s` is not a label", LIT(name)); + error(ident, "'%.*s' is not a label", LIT(name)); return; } } @@ -1619,7 +1619,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_ast_node(us, UsingStmt, node); if (us->list.count == 0) { - error(us->token, "Empty `using` list"); + error(us->token, "Empty 'using' list"); return; } for_array(i, us->list) { @@ -1637,10 +1637,10 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { is_selector = true; break; case AstNode_Implicit: - error(us->token, "`using` applied to an implicit value"); + error(us->token, "'using' applied to an implicit value"); continue; default: - error(us->token, "`using` can only be applied to an entity, got %.*s", LIT(ast_node_strings[expr->kind])); + error(us->token, "'using' can only be applied to an entity, got %.*s", LIT(ast_node_strings[expr->kind])); continue; } @@ -1697,7 +1697,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Token token = name->Ident.token; String str = token.string; Entity *found = nullptr; - // NOTE(bill): Ignore assignments to `_` + // NOTE(bill): Ignore assignments to '_' if (!is_blank_ident(str)) { found = current_scope_lookup_entity(c->context.scope, str); } @@ -1714,7 +1714,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } else { TokenPos pos = found->token.pos; error(token, - "Redeclaration of `%.*s` in this scope\n" + "Redeclaration of '%.*s' in this scope\n" "\tat %.*s(%td:%td)", LIT(str), LIT(pos.file), pos.line, pos.column); entity = found; @@ -1734,12 +1734,12 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { init_type = t_invalid; } else if (is_type_polymorphic(base_type(init_type))) { gbString str = type_to_string(init_type); - error(vd->type, "Invalid use of a polymorphic type `%s` in variable declaration", str); + error(vd->type, "Invalid use of a polymorphic type '%s' in variable declaration", str); gb_string_free(str); init_type = t_invalid; } else if (is_type_empty_union(init_type)) { gbString str = type_to_string(init_type); - error(vd->type, "An empty union `%s` cannot be instantiated in variable declaration", str); + error(vd->type, "An empty union '%s' cannot be instantiated in variable declaration", str); gb_string_free(str); init_type = t_invalid; } @@ -1800,7 +1800,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Type *other_type = base_type(f->type); if (!are_types_identical(this_type, other_type)) { error(e->token, - "Foreign entity `%.*s` previously declared elsewhere with a different type\n" + "Foreign entity '%.*s' previously declared elsewhere with a different type\n" "\tat %.*s(%td:%td)", LIT(name), LIT(pos.file), pos.line, pos.column); } @@ -1814,8 +1814,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (vd->is_using != 0) { Token token = ast_node_token(node); if (vd->type != nullptr && entity_count > 1) { - error(token, "`using` can only be applied to one variable of the same type"); - // TODO(bill): Should a `continue` happen here? + error(token, "'using' can only be applied to one variable of the same type"); + // TODO(bill): Should a 'continue' happen here? } for (isize entity_index = 0; entity_index < entity_count; entity_index++) { @@ -1831,7 +1831,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Type *t = base_type(type_deref(e->type)); if (is_blank_ident(name)) { - error(token, "`using` cannot be applied variable declared as `_`"); + 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); for_array(i, scope->elements.entries) { @@ -1841,14 +1841,14 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { uvar->Variable.is_immutable = is_immutable; Entity *prev = scope_insert_entity(c->context.scope, uvar); if (prev != nullptr) { - error(token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string)); + error(token, "Namespace collision while 'using' '%.*s' of: %.*s", LIT(name), LIT(prev->token.string)); return; } } } } else { // NOTE(bill): skip the rest to remove extra errors - error(token, "`using` can only be applied to variables of type struct or raw_union"); + error(token, "'using' can only be applied to variables of type struct or raw_union"); return; } } diff --git a/src/check_type.cpp b/src/check_type.cpp index fe9c9c4ae..65a609e36 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -18,9 +18,9 @@ void populate_using_entity_map(Checker *c, AstNode *node, Type *t, Map Entity *e = *found; // TODO(bill): Better type error if (str != nullptr) { - error(e->token, "`%.*s` is already declared in `%s`", LIT(name), str); + error(e->token, "'%.*s' is already declared in '%s'", LIT(name), str); } else { - error(e->token, "`%.*s` is already declared`", LIT(name)); + error(e->token, "'%.*s' is already declared", LIT(name)); } } else { map_set(entity_map, key, f); @@ -42,11 +42,11 @@ void check_struct_field_decl(Checker *c, AstNode *decl, Array *fields, Operand operand = {Addressing_Invalid}; check_expr(c, &operand, ws->cond); if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) { - error(ws->cond, "Non-constant boolean `when` condition"); + error(ws->cond, "Non-constant boolean 'when' condition"); return; } if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) { - error(ws->cond, "Invalid body for `when` statement"); + error(ws->cond, "Invalid body for 'when' statement"); return; } if (operand.value.kind == ExactValue_Bool && @@ -67,7 +67,7 @@ void check_struct_field_decl(Checker *c, AstNode *decl, Array *fields, check_struct_field_decl(c, ws->else_stmt, fields, entity_map, struct_node, context, allow_default_values); break; default: - error(ws->else_stmt, "Invalid `else` statement in `when` statement"); + error(ws->else_stmt, "Invalid 'else' statement in 'when' statement"); break; } } @@ -85,7 +85,7 @@ void check_struct_field_decl(Checker *c, AstNode *decl, Array *fields, bool is_using = vd->is_using; if (is_using && vd->names.count > 1) { - error(vd->names[0], "Cannot apply `using` to more than one of the same type"); + error(vd->names[0], "Cannot apply 'using' to more than one of the same type"); is_using = false; } @@ -175,7 +175,7 @@ void check_struct_field_decl(Checker *c, AstNode *decl, Array *fields, error(b.expr, "Default field value must be a constant"); } else if (is_type_any(e->type) || is_type_union(e->type)) { gbString str = type_to_string(e->type); - error(b.expr, "A struct field of type `%s` cannot have a default value", str); + error(b.expr, "A struct field of type '%s' cannot have a default value", str); gb_string_free(str); } else { e->Variable.default_value = b.value; @@ -196,7 +196,7 @@ void check_struct_field_decl(Checker *c, AstNode *decl, Array *fields, Entity *e = *found; // NOTE(bill): Scope checking already checks the declaration but in many cases, this can happen so why not? // This may be a little janky but it's not really that much of a problem - error(name_token, "`%.*s` is already declared in this type", LIT(name_token.string)); + error(name_token, "'%.*s' is already declared in this type", LIT(name_token.string)); error(e->token, "\tpreviously declared"); } else { map_set(entity_map, key, e); @@ -235,11 +235,11 @@ void check_struct_field_decl(Checker *c, AstNode *decl, Array *fields, using_index_expr = (*fields)[fields->count-1]; } else { (*fields)[fields->count-1]->flags &= ~EntityFlag_Using; - error(name_token, "Previous `using` for an index expression `%.*s`", LIT(name_token.string)); + error(name_token, "Previous 'using' for an index expression '%.*s'", LIT(name_token.string)); } } else { gbString type_str = type_to_string(first_type); - error(name_token, "`using` cannot be applied to the field `%.*s` of type `%s`", LIT(name_token.string), type_str); + error(name_token, "'using' cannot be applied to the field '%.*s' of type '%s'", LIT(name_token.string), type_str); gb_string_free(type_str); return; } @@ -382,7 +382,7 @@ Array check_struct_fields(Checker *c, AstNode *node, Array } if (is_type_empty_union(type)) { gbString str = type_to_string(type); - error(params[i], "Invalid use of an empty union `%s`", str); + error(params[i], "Invalid use of an empty union '%s'", str); gb_string_free(str); type = t_invalid; } @@ -436,11 +436,11 @@ Array check_struct_fields(Checker *c, AstNode *node, Array using_index_expr = fields[fields.count-1]; } else { fields[fields.count-1]->flags &= ~EntityFlag_Using; - error(name_token, "Previous `using` for an index expression `%.*s`", LIT(name_token.string)); + error(name_token, "Previous 'using' for an index expression '%.*s'", LIT(name_token.string)); } } else { gbString type_str = type_to_string(first_type); - error(name_token, "`using` cannot be applied to the field `%.*s` of type `%s`", LIT(name_token.string), type_str); + error(name_token, "'using' cannot be applied to the field '%.*s' of type '%s'", LIT(name_token.string), type_str); gb_string_free(type_str); continue; } @@ -465,7 +465,7 @@ gb_global gbAllocator __checker_allocator = {}; GB_COMPARE_PROC(cmp_reorder_struct_fields) { // Rule: - // `using` over non-`using` + // 'using' over non-'using' // Biggest to smallest alignment // if same alignment: biggest to smallest size // if same size: order by source order @@ -847,7 +847,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Arrayalign != nullptr) { if (st->is_packed) { - syntax_error(st->align, "`#align` cannot be applied with `#packed`"); + syntax_error(st->align, "'#align' cannot be applied with '#packed'"); return; } i64 custom_align = 1; @@ -881,14 +881,14 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) { if (is_type_untyped(t) || is_type_empty_union(t)) { ok = false; gbString str = type_to_string(t); - error(node, "Invalid variant type in union `%s`", str); + error(node, "Invalid variant type in union '%s'", str); gb_string_free(str); } else { for_array(j, variants) { if (are_types_identical(t, variants[j])) { ok = false; gbString str = type_to_string(t); - error(node, "Duplicate variant type `%s`", str); + error(node, "Duplicate variant type '%s'", str); gb_string_free(str); break; } @@ -935,7 +935,7 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod return; } - // NOTE(bill): Must be up here for the `check_init_constant` system + // NOTE(bill): Must be up here for the 'check_init_constant' system enum_type->Enum.base_type = base_type; Map entity_map = {}; // Key: String @@ -997,19 +997,19 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod if (is_blank_ident(name)) { continue; } else if (name == "count") { - error(field, "`count` is a reserved identifier for enumerations"); + error(field, "'count' is a reserved identifier for enumerations"); continue; } else if (name == "min_value") { - error(field, "`min_value` is a reserved identifier for enumerations"); + error(field, "'min_value' is a reserved identifier for enumerations"); continue; } else if (name == "max_value") { - error(field, "`max_value` is a reserved identifier for enumerations"); + error(field, "'max_value' is a reserved identifier for enumerations"); continue; } else if (name == "names") { - error(field, "`names` is a reserved identifier for enumerations"); + error(field, "'names' is a reserved identifier for enumerations"); continue; }/* else if (name == "base_type") { - error(field, "`base_type` is a reserved identifier for enumerations"); + error(field, "'base_type' is a reserved identifier for enumerations"); continue; } */ @@ -1026,7 +1026,7 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod HashKey key = hash_string(name); if (map_get(&entity_map, key) != nullptr) { - error(ident, "`%.*s` is already declared in this enumeration", LIT(name)); + 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); @@ -1104,7 +1104,7 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, AstNode *node) { HashKey key = hash_string(name); if (!is_blank_ident(name) && map_get(&entity_map, key) != nullptr) { - error(ident, "`%.*s` is already declared in this bit field", LIT(name)); + 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); @@ -1204,7 +1204,7 @@ Type *determine_type_from_polymorphic(Checker *c, Type *poly_type, Operand opera gbString ots = type_to_string(operand.type); defer (gb_string_free(pts)); defer (gb_string_free(ots)); - error(operand.expr, "Cannot determine polymorphic type from parameter: `%s` to `%s`", ots, pts); + error(operand.expr, "Cannot determine polymorphic type from parameter: '%s' to '%s'", ots, pts); } return t_invalid; } @@ -1432,7 +1432,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari } if (is_type_empty_union(type)) { gbString str = type_to_string(type); - error(param, "Invalid use of an empty union `%s`", str); + error(param, "Invalid use of an empty union '%s'", str); gb_string_free(str); type = t_invalid; } @@ -1441,7 +1441,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (p->flags&FieldFlag_c_vararg) { if (p->type == nullptr || p->type->kind != AstNode_Ellipsis) { - error(param, "`#c_vararg` can only be applied to variadic type fields"); + error(param, "'#c_vararg' can only be applied to variadic type fields"); p->flags &= ~FieldFlag_c_vararg; // Remove the flag } else { is_c_vararg = true; @@ -1450,10 +1450,10 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (is_constant_value) { if (is_type_param) { - error(param, "`$` is not needed for a `type` parameter"); + error(param, "'$' is not needed for a 'type' parameter"); } if (p->flags&FieldFlag_no_alias) { - error(param, "`#no_alias` can only be applied to variable fields of pointer type"); + error(param, "'#no_alias' can only be applied to variable fields of pointer type"); p->flags &= ~FieldFlag_no_alias; // Remove the flag } @@ -1480,7 +1480,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari } if (is_type_polymorphic(type)) { gbString str = type_to_string(type); - error(o.expr, "Cannot pass polymorphic type as a parameter, got `%s`", str); + error(o.expr, "Cannot pass polymorphic type as a parameter, got '%s'", str); gb_string_free(str); success = false; type = t_invalid; @@ -1491,7 +1491,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (!c->context.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); + error(o.expr, "Cannot convert type '%s' to the specialization '%s'", t, s); gb_string_free(s); gb_string_free(t); } @@ -1517,7 +1517,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (p->flags&FieldFlag_no_alias) { if (!is_type_pointer(type)) { - error(name, "`#no_alias` can only be applied to fields of pointer type"); + error(name, "'#no_alias' can only be applied to fields of pointer type"); p->flags &= ~FieldFlag_no_alias; // Remove the flag } } @@ -1713,7 +1713,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { continue; } if (x == y) { - error(variables[j]->token, "Duplicate return value name `%.*s`", LIT(y)); + error(variables[j]->token, "Duplicate return value name '%.*s'", LIT(y)); } } } @@ -1912,7 +1912,7 @@ bool abi_compat_return_by_value(gbAllocator a, ProcCallingConvention cc, Type *a return false; } -// NOTE(bill): `operands` is for generating non generic procedure type +// NOTE(bill): 'operands' is for generating non generic procedure type bool check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node, Array *operands) { ast_node(pt, ProcType, proc_type_node); @@ -2147,7 +2147,7 @@ void check_map_type(Checker *c, Type *type, AstNode *node) { error(node, "A boolean cannot be used as a key for a map, use an array instead for this case"); } else { gbString str = type_to_string(key); - error(node, "Invalid type of a key for a map, got `%s`", str); + error(node, "Invalid type of a key for a map, got '%s'", str); gb_string_free(str); } } @@ -2159,7 +2159,7 @@ void check_map_type(Checker *c, Type *type, AstNode *node) { init_preload(c); generate_map_internal_types(c->allocator, type); - // error(node, "`map` types are not yet implemented"); + // error(node, "'map' types are not yet implemented"); } bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) { @@ -2185,13 +2185,13 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case Addressing_NoValue: err_str = expr_to_string(e); - error(e, "`%s` used as a type", err_str); + error(e, "'%s' used as a type", err_str); gb_string_free(err_str); break; default: err_str = expr_to_string(e); - error(e, "`%s` used as a type when not a type", err_str); + error(e, "'%s' used as a type when not a type", err_str); gb_string_free(err_str); break; } @@ -2202,7 +2202,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) case_end; case_ast_node(at, AliasType, e); - error(e, "Invalid use of `#alias`"); + error(e, "Invalid use of '#alias'"); // NOTE(bill): Treat it as a HelperType to remove errors return check_type_internal(c, at->type, type, named_type); case_end; @@ -2241,7 +2241,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) add_entity(c, ps, ident, e); add_entity(c, s, ident, e); } else { - error(ident, "Invalid use of a polymorphic parameter `$%.*s`", LIT(token.string)); + error(ident, "Invalid use of a polymorphic parameter '$%.*s'", LIT(token.string)); *type = t_invalid; return false; } @@ -2263,12 +2263,12 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) return true; case Addressing_NoValue: err_str = expr_to_string(e); - error(e, "`%s` used as a type", err_str); + error(e, "'%s' used as a type", err_str); gb_string_free(err_str); break; default: err_str = expr_to_string(e); - error(e, "`%s` is not a type", err_str); + error(e, "'%s' is not a type", err_str); gb_string_free(err_str); break; } @@ -2341,7 +2341,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) Type *be = base_type(elem); if (is_type_vector(be) || (!is_type_boolean(be) && !is_type_numeric(be) && be->kind != Type_Generic)) { gbString err_str = type_to_string(elem); - error(vt->elem, "Vector element type must be numerical or a boolean, got `%s`", err_str); + error(vt->elem, "Vector element type must be numerical or a boolean, got '%s'", err_str); gb_string_free(err_str); } *type = make_type_vector(c->allocator, elem, count, generic_type); @@ -2434,7 +2434,7 @@ Type *check_type(Checker *c, AstNode *e, Type *named_type) { if (!ok) { gbString err_str = expr_to_string(e); - error(e, "`%s` is not a type", err_str); + error(e, "'%s' is not a type", err_str); gb_string_free(err_str); type = t_invalid; } @@ -2447,7 +2447,7 @@ Type *check_type(Checker *c, AstNode *e, Type *named_type) { type->Named.base == nullptr) { // IMPORTANT TODO(bill): Is this a serious error?! #if 0 - error(e, "Invalid type definition of `%.*s`", LIT(type->Named.name)); + error(e, "Invalid type definition of '%.*s'", LIT(type->Named.name)); #endif type->Named.base = t_invalid; } @@ -2455,7 +2455,7 @@ Type *check_type(Checker *c, AstNode *e, Type *named_type) { #if 0 if (!c->context.allow_polymorphic_types && is_type_polymorphic(type)) { gbString str = type_to_string(type); - error(e, "Invalid use of a polymorphic type `%s`", str); + error(e, "Invalid use of a polymorphic type '%s'", str); gb_string_free(str); type = t_invalid; } diff --git a/src/checker.cpp b/src/checker.cpp index 61c2a4015..77a04d72e 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -230,7 +230,7 @@ struct Scope { Array shared; Array delayed_file_decls; PtrSet imported; - PtrSet exported; // NOTE(bhall): Contains `using import` too + PtrSet exported; // NOTE(bhall): Contains 'using import' too bool is_proc; bool is_global; bool is_file; @@ -617,7 +617,7 @@ void destroy_scope(Scope *scope) { if (e->kind == Entity_Variable) { if (!(e->flags & EntityFlag_Used)) { #if 0 - warning(e->token, "Unused variable `%.*s`", LIT(e->token.string)); + warning(e->token, "Unused variable '%.*s'", LIT(e->token.string)); #endif } } @@ -833,7 +833,7 @@ void add_declaration_dependency(Checker *c, Entity *e) { Entity *add_global_entity(Entity *entity) { String name = entity->token.string; if (gb_memchr(name.text, ' ', name.len)) { - return entity; // NOTE(bill): `untyped thing` + return entity; // NOTE(bill): 'untyped thing' } if (scope_insert_entity(universal_scope, entity)) { compiler_error("double declaration"); @@ -1123,7 +1123,7 @@ isize type_info_index(CheckerInfo *info, Type *type, bool error_on_failure) { } if (error_on_failure && entry_index < 0) { - compiler_error("TypeInfo for `%s` could not be found", type_to_string(type)); + compiler_error("TypeInfo for '%s' could not be found", type_to_string(type)); } return entry_index; } @@ -1189,7 +1189,7 @@ bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) { return false; } error(entity->token, - "Redeclaration of `%.*s` in this scope through `using`\n" + "Redeclaration of '%.*s' in this scope through 'using'\n" "\tat %.*s(%td:%td)", LIT(name), LIT(up->token.pos.file), up->token.pos.line, up->token.pos.column); @@ -1200,7 +1200,7 @@ bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) { return false; } error(entity->token, - "Redeclaration of `%.*s` in this scope\n" + "Redeclaration of '%.*s' in this scope\n" "\tat %.*s(%td:%td)", LIT(name), LIT(pos.file), pos.line, pos.column); @@ -1565,26 +1565,26 @@ Array generate_entity_dependency_graph(CheckerInfo *info) { EntityGraphNode *n = entry->value; if (e->kind == Entity_Procedure) { - // Connect each pred `p` of `n` with each succ `s` and from + // Connect each pred 'p' of 'n' with each succ 's' and from // the procedure node for_array(j, n->pred.entries) { EntityGraphNode *p = cast(EntityGraphNode *)n->pred.entries[j].ptr; // Ignore self-cycles if (p != n) { - // Each succ `s` of `n` becomes a succ of `p`, and - // each pred `p` of `n` becomes a pred of `s` + // Each succ 's' of 'n' becomes a succ of 'p', and + // each pred 'p' of 'n' becomes a pred of 's' for_array(k, n->succ.entries) { EntityGraphNode *s = n->succ.entries[k].ptr; // Ignore self-cycles if (s != n) { entity_graph_node_set_add(&p->succ, s); entity_graph_node_set_add(&s->pred, p); - // Remove edge to `n` + // Remove edge to 'n' entity_graph_node_set_remove(&s->pred, n); } } - // Remove edge to `n` + // Remove edge to 'n' entity_graph_node_set_remove(&p->succ, n); } } @@ -1609,8 +1609,8 @@ Array generate_entity_dependency_graph(CheckerInfo *info) { Entity *find_core_entity(Checker *c, String name) { Entity *e = current_scope_lookup_entity(c->global_scope, name); if (e == nullptr) { - compiler_error("Could not find type declaration for `%.*s`\n" - "Is `_preload.odin` missing from the `core` directory relative to odin.exe?", LIT(name)); + compiler_error("Could not find type declaration for '%.*s'\n" + "Is '_preload.odin' missing from the 'core' directory relative to odin.exe?", LIT(name)); // NOTE(bill): This will exit the program as it's cannot continue without it! } return e; @@ -1619,8 +1619,8 @@ Entity *find_core_entity(Checker *c, String name) { Type *find_core_type(Checker *c, String name) { Entity *e = current_scope_lookup_entity(c->global_scope, name); if (e == nullptr) { - compiler_error("Could not find type declaration for `%.*s`\n" - "Is `_preload.odin` missing from the `core` directory relative to odin.exe?", LIT(name)); + compiler_error("Could not find type declaration for '%.*s'\n" + "Is '_preload.odin' missing from the 'core' directory relative to odin.exe?", LIT(name)); // NOTE(bill): This will exit the program as it's cannot continue without it! } return e->type; @@ -1812,25 +1812,25 @@ void check_procedure_overloading(Checker *c, Entity *e) { ProcTypeOverloadKind kind = are_proc_types_overload_safe(p->type, q->type); switch (kind) { case ProcOverload_Identical: - error(p->token, "Overloaded procedure `%.*s` as the same type as another procedure in this scope", LIT(name)); + error(p->token, "Overloaded procedure '%.*s' as the same type as another procedure in this scope", LIT(name)); is_invalid = true; break; // case ProcOverload_CallingConvention: - // error(p->token, "Overloaded procedure `%.*s` as the same type as another procedure in this scope", LIT(name)); + // error(p->token, "Overloaded procedure '%.*s' as the same type as another procedure in this scope", LIT(name)); // is_invalid = true; // break; case ProcOverload_ParamVariadic: - error(p->token, "Overloaded procedure `%.*s` as the same type as another procedure in this scope", LIT(name)); + error(p->token, "Overloaded procedure '%.*s' as the same type as another procedure in this scope", LIT(name)); is_invalid = true; break; case ProcOverload_ResultCount: case ProcOverload_ResultTypes: - error(p->token, "Overloaded procedure `%.*s` as the same parameters but different results in this scope", LIT(name)); + error(p->token, "Overloaded procedure '%.*s' as the same parameters but different results in this scope", LIT(name)); is_invalid = true; break; case ProcOverload_Polymorphic: #if 0 - error(p->token, "Overloaded procedure `%.*s` has a polymorphic counterpart in this scope which is not allowed", LIT(name)); + error(p->token, "Overloaded procedure '%.*s' has a polymorphic counterpart in this scope which is not allowed", LIT(name)); is_invalid = true; #endif break; @@ -1883,24 +1883,24 @@ DECL_ATTRIBUTE_PROC(foreign_block_decl_attribute) { if (value.kind == ExactValue_String) { auto cc = string_to_calling_convention(value.value_string); if (cc == ProcCC_Invalid) { - error(elem, "Unknown procedure calling convention: `%.*s`\n", LIT(value.value_string)); + error(elem, "Unknown procedure calling convention: '%.*s'\n", LIT(value.value_string)); } else { c->context.foreign_context.default_cc = cc; } } else { - error(elem, "Expected a string value for `%.*s`", LIT(name)); + error(elem, "Expected a string value for '%.*s'", LIT(name)); } return true; } else if (name == "link_prefix") { if (value.kind == ExactValue_String) { String link_prefix = value.value_string; if (!is_foreign_name_valid(link_prefix)) { - error(elem, "Invalid link prefix: `%.*s`\n", LIT(link_prefix)); + error(elem, "Invalid link prefix: '%.*s'\n", LIT(link_prefix)); } else { c->context.foreign_context.link_prefix = link_prefix; } } else { - error(elem, "Expected a string value for `%.*s`", LIT(name)); + error(elem, "Expected a string value for '%.*s'", LIT(name)); } return true; } @@ -1916,7 +1916,7 @@ DECL_ATTRIBUTE_PROC(proc_decl_attribute) { error(elem, "Invalid link name: %.*s", LIT(ac->link_name)); } } else { - error(elem, "Expected a string value for `%.*s`", LIT(name)); + error(elem, "Expected a string value for '%.*s'", LIT(name)); } return true; } else if (name == "link_prefix") { @@ -1926,7 +1926,7 @@ DECL_ATTRIBUTE_PROC(proc_decl_attribute) { error(elem, "Invalid link prefix: %.*s", LIT(ac->link_prefix)); } } else { - error(elem, "Expected a string value for `%.*s`", LIT(name)); + error(elem, "Expected a string value for '%.*s'", LIT(name)); } return true; } @@ -1935,7 +1935,7 @@ DECL_ATTRIBUTE_PROC(proc_decl_attribute) { DECL_ATTRIBUTE_PROC(var_decl_attribute) { if (c->context.curr_proc_decl != nullptr) { - error(elem, "Only a variable at file scope can have a `%.*s`", LIT(name)); + error(elem, "Only a variable at file scope can have a '%.*s'", LIT(name)); return true; } @@ -1946,7 +1946,7 @@ DECL_ATTRIBUTE_PROC(var_decl_attribute) { error(elem, "Invalid link name: %.*s", LIT(ac->link_name)); } } else { - error(elem, "Expected a string value for `%.*s`", LIT(name)); + error(elem, "Expected a string value for '%.*s'", LIT(name)); } return true; } else if (name == "link_prefix") { @@ -1956,7 +1956,7 @@ DECL_ATTRIBUTE_PROC(var_decl_attribute) { error(elem, "Invalid link prefix: %.*s", LIT(ac->link_prefix)); } } else { - error(elem, "Expected a string value for `%.*s`", LIT(name)); + error(elem, "Expected a string value for '%.*s'", LIT(name)); } return true; } else if (name == "thread_local") { @@ -1973,10 +1973,10 @@ DECL_ATTRIBUTE_PROC(var_decl_attribute) { model == "localexec") { ac->thread_local_model = model; } else { - error(elem, "Invalid thread local model `%.*s`", LIT(model)); + error(elem, "Invalid thread local model '%.*s'", LIT(model)); } } else { - error(elem, "Expected either no value or a string for `%.*s`", LIT(name)); + error(elem, "Expected either no value or a string for '%.*s'", LIT(name)); } return true; } @@ -2039,14 +2039,14 @@ void check_decl_attributes(Checker *c, Array attributes, DeclAttribut } if (string_set_exists(&set, name)) { - error(elem, "Previous declaration of `%.*s`", LIT(name)); + error(elem, "Previous declaration of '%.*s'", LIT(name)); continue; } else { string_set_add(&set, name); } if (!proc(c, elem, name, ev, ac)) { - error(elem, "Unknown attribute element name `%.*s`", LIT(name)); + error(elem, "Unknown attribute element name '%.*s'", LIT(name)); } } } @@ -2075,7 +2075,7 @@ bool check_arity_match(Checker *c, AstNodeValueDecl *vd, bool is_global) { if (lhs < vd->values.count) { AstNode *n = vd->values[lhs]; gbString str = expr_to_string(n); - error(n, "Extra initial expression `%s`", str); + error(n, "Extra initial expression '%s'", str); gb_string_free(str); } else { error(vd->names[0], "Extra initial expression"); @@ -2085,7 +2085,7 @@ bool check_arity_match(Checker *c, AstNodeValueDecl *vd, bool is_global) { if (!is_global && rhs != 1) { AstNode *n = vd->names[rhs]; gbString str = expr_to_string(n); - error(n, "Missing expression for `%s`", str); + error(n, "Missing expression for '%s'", str); gb_string_free(str); return false; } else if (is_global) { @@ -2103,10 +2103,10 @@ void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { if (!ws->is_cond_determined) { check_expr(c, &operand, ws->cond); if (operand.mode != Addressing_Invalid && !is_type_boolean(operand.type)) { - error(ws->cond, "Non-boolean condition in `when` statement"); + error(ws->cond, "Non-boolean condition in 'when' statement"); } if (operand.mode != Addressing_Constant) { - error(ws->cond, "Non-constant condition in `when` statement"); + error(ws->cond, "Non-constant condition in 'when' statement"); } ws->is_cond_determined = true; @@ -2114,7 +2114,7 @@ void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { } if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) { - error(ws->cond, "Invalid body for `when` statement"); + error(ws->cond, "Invalid body for 'when' statement"); } else { if (ws->determined_cond) { check_collect_entities(c, ws->body->BlockStmt.stmts); @@ -2127,7 +2127,7 @@ void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { check_collect_entities_from_when_stmt(c, &ws->else_stmt->WhenStmt); break; default: - error(ws->else_stmt, "Invalid `else` statement in `when` statement"); + error(ws->else_stmt, "Invalid 'else' statement in 'when' statement"); break; } } @@ -2176,7 +2176,7 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { if (vd->is_using) { vd->is_using = false; // NOTE(bill): This error will be only caught once - error(name, "`using` is not allowed at the file scope"); + error(name, "'using' is not allowed at the file scope"); } AstNode *fl = c->context.foreign_context.curr_library; @@ -2282,7 +2282,7 @@ void check_collect_value_decl(Checker *c, AstNode *decl) { 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) { - gb_printf_err("\tDid you forget to append `---` to the procedure?\n"); + gb_printf_err("\tDid you forget to append '---' to the procedure?\n"); } } } @@ -2309,7 +2309,7 @@ void check_add_foreign_block_decl(Checker *c, AstNode *decl) { } else if (foreign_library->kind == AstNode_Implicit && foreign_library->Implicit.kind == Token_export) { c->context.foreign_context.in_export = true; } else { - error(foreign_library, "Foreign block name must be an identifier or `export`"); + error(foreign_library, "Foreign block name must be an identifier or 'export'"); c->context.foreign_context.curr_library = nullptr; } @@ -2386,7 +2386,7 @@ void check_collect_entities(Checker *c, Array nodes) { } } - // NOTE(bill): `when` stmts need to be handled after the other as the condition may refer to something + // 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 || c->context.collect_delayed_decls) { for_array(i, nodes) { @@ -2427,11 +2427,11 @@ void check_all_global_entities(Checker *c) { if (e->token.string == "main") { if (e->kind != Entity_Procedure) { if (e->scope->is_init) { - error(e->token, "`main` is reserved as the entry point procedure in the initial scope"); + error(e->token, "'main' is reserved as the entry point procedure in the initial scope"); continue; } } else if (e->scope->is_global) { - error(e->token, "`main` is reserved as the entry point procedure in the initial scope"); + error(e->token, "'main' is reserved as the entry point procedure in the initial scope"); continue; } } @@ -2563,7 +2563,7 @@ void add_import_dependency_node(Checker *c, AstNode *decl, Mapsucc, m); import_graph_node_set_add(&m->pred, n); ptr_set_add(&m->scope->imported, n->scope); @@ -2825,7 +2825,7 @@ void check_add_export_decl(Checker *c, AstNodeExportDecl *ed) { } if (parent_scope->is_global) { - error(ed->token, "`export` cannot be used on #shared_global_scope"); + error(ed->token, "'export' cannot be used on #shared_global_scope"); return; } @@ -2877,10 +2877,10 @@ void check_add_foreign_import_decl(Checker *c, AstNode *decl) { switch (file_err) { case gbFileError_Invalid: - error(decl, "Invalid file or cannot be found (`%.*s`)", LIT(fullpath)); + error(decl, "Invalid file or cannot be found ('%.*s')", LIT(fullpath)); return; case gbFileError_NotExists: - error(decl, "File cannot be found (`%.*s`)", LIT(fullpath)); + error(decl, "File cannot be found ('%.*s')", LIT(fullpath)); return; } } @@ -2930,10 +2930,10 @@ bool collect_checked_files_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { if (!ws->is_cond_determined) { check_expr(c, &operand, ws->cond); if (operand.mode != Addressing_Invalid && !is_type_boolean(operand.type)) { - error(ws->cond, "Non-boolean condition in `when` statement"); + error(ws->cond, "Non-boolean condition in 'when' statement"); } if (operand.mode != Addressing_Constant) { - error(ws->cond, "Non-constant condition in `when` statement"); + error(ws->cond, "Non-constant condition in 'when' statement"); } ws->is_cond_determined = true; @@ -2941,7 +2941,7 @@ bool collect_checked_files_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { } if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) { - error(ws->cond, "Invalid body for `when` statement"); + error(ws->cond, "Invalid body for 'when' statement"); } else { if (ws->determined_cond) { return collect_checked_files_from_import_decl_list(c, ws->body->BlockStmt.stmts); @@ -2952,7 +2952,7 @@ bool collect_checked_files_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { case AstNode_WhenStmt: return collect_checked_files_from_when_stmt(c, &ws->else_stmt->WhenStmt); default: - error(ws->else_stmt, "Invalid `else` statement in `when` statement"); + error(ws->else_stmt, "Invalid 'else' statement in 'when' statement"); break; } } @@ -2994,10 +2994,10 @@ bool collect_file_decls_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { if (!ws->is_cond_determined) { check_expr(c, &operand, ws->cond); if (operand.mode != Addressing_Invalid && !is_type_boolean(operand.type)) { - error(ws->cond, "Non-boolean condition in `when` statement"); + error(ws->cond, "Non-boolean condition in 'when' statement"); } if (operand.mode != Addressing_Constant) { - error(ws->cond, "Non-constant condition in `when` statement"); + error(ws->cond, "Non-constant condition in 'when' statement"); } ws->is_cond_determined = true; @@ -3005,7 +3005,7 @@ bool collect_file_decls_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { } if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) { - error(ws->cond, "Invalid body for `when` statement"); + error(ws->cond, "Invalid body for 'when' statement"); } else { if (ws->determined_cond) { return collect_file_decls(c, ws->body->BlockStmt.stmts); @@ -3016,7 +3016,7 @@ bool collect_file_decls_from_when_stmt(Checker *c, AstNodeWhenStmt *ws) { case AstNode_WhenStmt: return collect_file_decls_from_when_stmt(c, &ws->else_stmt->WhenStmt); default: - error(ws->else_stmt, "Invalid `else` statement in `when` statement"); + error(ws->else_stmt, "Invalid 'else' statement in 'when' statement"); break; } } @@ -3124,17 +3124,17 @@ void check_import_entities(Checker *c) { if (path.count == 1) { ImportPathItem item = path[0]; String filename = fn(item); - error(item.decl, "Self importation of `%.*s`", LIT(filename)); + error(item.decl, "Self importation of '%.*s'", LIT(filename)); } else if (path.count > 0) { ImportPathItem item = path[path.count-1]; String filename = fn(item); - error(item.decl, "Cyclic importation of `%.*s`", LIT(filename)); + error(item.decl, "Cyclic importation of '%.*s'", LIT(filename)); for (isize i = 0; i < path.count; i++) { - error(item.decl, "`%.*s` refers to", LIT(filename)); + error(item.decl, "'%.*s' refers to", LIT(filename)); item = path[i]; filename = fn(item); } - error(item.decl, "`%.*s`", LIT(filename)); + error(item.decl, "'%.*s'", LIT(filename)); } } @@ -3287,12 +3287,12 @@ void calculate_global_init_order(Checker *c) { if (path.count > 0) { Entity *e = path[0]; - error(e->token, "Cyclic initialization of `%.*s`", LIT(e->token.string)); + error(e->token, "Cyclic initialization of '%.*s'", LIT(e->token.string)); for (isize i = path.count-1; i >= 0; i--) { - error(e->token, "\t`%.*s` refers to", LIT(e->token.string)); + error(e->token, "\t'%.*s' refers to", LIT(e->token.string)); e = path[i]; } - error(e->token, "\t`%.*s`", LIT(e->token.string)); + error(e->token, "\t'%.*s'", LIT(e->token.string)); } } @@ -3328,7 +3328,7 @@ void calculate_global_init_order(Checker *c) { Entity *e = d->entities[j]; if (j == 0) gb_printf("\t"); if (j > 0) gb_printf(", "); - gb_printf("`%.*s` %td", LIT(e->token.string), e->order_in_src); + gb_printf("'%.*s' %td", LIT(e->token.string), e->order_in_src); } gb_printf("\n"); } @@ -3365,7 +3365,7 @@ void check_parsed_files(Checker *c) { check_import_entities(c); check_all_global_entities(c); - init_preload(c); // NOTE(bill): This could be setup previously through the use of `type_info_of` + init_preload(c); // NOTE(bill): This could be setup previously through the use of 'type_info_of' // Check procedure bodies // NOTE(bill): Nested procedures bodies will be added to this "queue" @@ -3458,7 +3458,7 @@ void check_parsed_files(Checker *c) { token.pos.column = 1; } - error(token, "Undefined entry point procedure `main`"); + error(token, "Undefined entry point procedure 'main'"); } } } diff --git a/src/exact_value.cpp b/src/exact_value.cpp index ac70b42f4..ce7a78832 100644 --- a/src/exact_value.cpp +++ b/src/exact_value.cpp @@ -246,7 +246,7 @@ ExactValue exact_value_from_basic_literal(Token token) { case Token_Imag: { String str = token.string; Rune last_rune = cast(Rune)str[str.len-1]; - str.len--; // Ignore the `i|j|k` + str.len--; // Ignore the 'i|j|k' f64 imag = float_from_string(str); if (last_rune == 'i') { @@ -344,7 +344,7 @@ ExactValue exact_value_make_imag(ExactValue v) { case ExactValue_Float: return exact_value_complex(0, v.value_float); default: - GB_PANIC("Expected an integer or float type for `exact_value_make_imag`"); + GB_PANIC("Expected an integer or float type for 'exact_value_make_imag'"); } ExactValue r = {ExactValue_Invalid}; return r; diff --git a/src/ir.cpp b/src/ir.cpp index 5f7333816..6a675a36c 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -93,7 +93,7 @@ struct irDefer { irBlock * block; union { AstNode *stmt; - // NOTE(bill): `instr` will be copied every time to create a new one + // NOTE(bill): 'instr' will be copied every time to create a new one irValue *instr; }; }; @@ -2268,7 +2268,7 @@ irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue * case Token_AndNot: { // NOTE(bill): x &~ y == x & (~y) == x & (y ~ -1) - // NOTE(bill): "not" `x` == `x` "xor" `-1` + // NOTE(bill): "not" 'x' == 'x' "xor" '-1' irValue *neg = ir_add_module_constant(proc->module, type, exact_value_i64(-1)); op = Token_Xor; right = ir_emit_arith(proc, op, right, neg, type); @@ -2988,7 +2988,7 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) { } else if (is_type_integer(dst)) { ev = exact_value_to_integer(ev); } else if (is_type_pointer(dst)) { - // IMPORTANT NOTE(bill): LLVM doesn't support pointer constants expect `null` + // IMPORTANT NOTE(bill): LLVM doesn't support pointer constants expect 'null' irValue *i = ir_add_module_constant(proc->module, t_uintptr, ev); return ir_emit(proc, ir_instr_conv(proc, irConv_inttoptr, i, t_uintptr, dst)); } @@ -3137,7 +3137,7 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) { } } - // NOTE(bill): This has to be done before `Pointer <-> Pointer` as it's + // NOTE(bill): This has to be done before 'Pointer <-> Pointer' as it's // subtype polymorphism casting if (check_is_assignable_to_using_subtype(src_type, t)) { Type *st = type_deref(src_type); @@ -3281,7 +3281,7 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) { gb_printf_err("Not Identical %s != %s\n", type_to_string(src), type_to_string(dst)); - GB_PANIC("Invalid type conversion: `%s` to `%s` for procedure `%.*s`", + GB_PANIC("Invalid type conversion: '%s' to '%s' for procedure '%.*s'", type_to_string(src_type), type_to_string(t), LIT(proc->name)); @@ -3338,7 +3338,7 @@ irValue *ir_emit_transmute(irProcedure *proc, irValue *value, Type *t) { i64 sz = type_size_of(m->allocator, src); i64 dz = type_size_of(m->allocator, dst); - GB_ASSERT_MSG(sz == dz, "Invalid transmute conversion: `%s` to `%s`", type_to_string(src_type), type_to_string(t)); + GB_ASSERT_MSG(sz == dz, "Invalid transmute conversion: '%s' to '%s'", type_to_string(src_type), type_to_string(t)); // NOTE(bill): Casting between an integer and a pointer cannot be done through a bitcast if (is_type_uintptr(src) && is_type_pointer(dst)) { @@ -3862,7 +3862,7 @@ void ir_gen_global_type_name(irModule *m, Entity *e, String name) { #if 0 if (is_type_union(e->type)) { Type *bt = base_type(e->type); - // NOTE(bill): Zeroth entry is null (for `match type` stmts) + // NOTE(bill): Zeroth entry is null (for 'match type' stmts) for (isize j = 1; j < bt->Struct.variant_count; j++) { ir_mangle_add_sub_type_name(m, bt->Struct.variants[j], name); } @@ -3923,7 +3923,7 @@ irValue *ir_emit_clamp(irProcedure *proc, Type *t, irValue *x, irValue *min, irV irValue *ir_find_global_variable(irProcedure *proc, String name) { irValue **value = map_get(&proc->module->members, hash_string(name)); - GB_ASSERT_MSG(value != nullptr, "Unable to find global variable `%.*s`", LIT(name)); + GB_ASSERT_MSG(value != nullptr, "Unable to find global variable '%.*s'", LIT(name)); return *value; } @@ -4298,7 +4298,7 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv } else if (is_type_string(type)) { ptr = ir_string_elem(proc, val); } else { - GB_PANIC("Invalid type to `free`"); + GB_PANIC("Invalid type to 'free'"); } if (ptr == nullptr) { @@ -4345,7 +4345,7 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv args[1] = capacity; return ir_emit_global_call(proc, "__dynamic_map_reserve", args, 2); } else { - GB_PANIC("Unknown type for `reserve`"); + GB_PANIC("Unknown type for 'reserve'"); } break; } @@ -4372,7 +4372,7 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv irValue *count_ptr = ir_emit_struct_ep(proc, ptr, 1); ir_emit_store(proc, count_ptr, v_zero); } else { - GB_PANIC("TODO(bill): ir clear for `%s`", type_to_string(t)); + GB_PANIC("TODO(bill): ir clear for '%s'", type_to_string(t)); } return nullptr; break; @@ -4778,7 +4778,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { GB_ASSERT_MSG(e != nullptr, "%s", expr_to_string(expr)); if (e->kind == Entity_Builtin) { Token token = ast_node_token(expr); - GB_PANIC("TODO(bill): ir_build_single_expr Entity_Builtin `%.*s`\n" + GB_PANIC("TODO(bill): ir_build_single_expr Entity_Builtin '%.*s'\n" "\t at %.*s(%td:%td)", LIT(builtin_procs[e->Builtin.id].name), LIT(token.pos.file), token.pos.line, token.pos.column); return nullptr; @@ -5715,7 +5715,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { case_end; case_ast_node(ce, CallExpr, expr); - // NOTE(bill): This is make sure you never need to have an `array_ev` + // NOTE(bill): This is make sure you never need to have an 'array_ev' irValue *e = ir_build_expr(proc, expr); irValue *v = ir_add_local_generated(proc, ir_type(e)); ir_emit_store(proc, v, e); @@ -5772,7 +5772,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { case Type_Struct: { - // TODO(bill): "constant" `#raw_union`s are not initialized constantly at the moment. + // TODO(bill): "constant" '#raw_union's are not initialized constantly at the moment. // NOTE(bill): This is due to the layout of the unions when printed to LLVM-IR bool is_raw_union = is_type_raw_union(bt); GB_ASSERT(is_type_struct(bt) || is_raw_union); @@ -6235,7 +6235,7 @@ void ir_build_when_stmt(irProcedure *proc, AstNodeWhenStmt *ws) { ir_build_when_stmt(proc, &ws->else_stmt->WhenStmt); break; default: - GB_PANIC("Invalid `else` statement in `when` statement"); + GB_PANIC("Invalid 'else' statement in 'when' statement"); break; } } @@ -6407,7 +6407,7 @@ void ir_build_range_string(irProcedure *proc, irValue *expr, Type *val_type, void ir_build_range_interval(irProcedure *proc, AstNodeBinaryExpr *node, Type *val_type, irValue **val_, irValue **idx_, irBlock **loop_, irBlock **done_) { // TODO(bill): How should the behaviour work for lower and upper bounds checking for iteration? - // If `lower` is changed, should `val` do so or is that not typical behaviour? + // If 'lower' is changed, should 'val' do so or is that not typical behaviour? irValue *lower = ir_build_expr(proc, node->left); irValue *upper = nullptr; @@ -7175,8 +7175,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { Type *parent_type = ir_type(parent); bool is_parent_ptr = is_type_pointer(ir_type(parent)); - MatchTypeKind match_type_kind = check_valid_type_match_type(ir_type(parent)); - GB_ASSERT(match_type_kind != MatchType_Invalid); + SwitchTypeKind switch_type_kind = check_valid_type_switch_type(ir_type(parent)); + GB_ASSERT(switch_type_kind != SwitchType_Invalid); irValue *parent_value = parent; @@ -7187,7 +7187,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { irValue *tag_index = nullptr; irValue *union_data = nullptr; - if (match_type_kind == MatchType_Union) { + if (switch_type_kind == SwitchType_Union) { ir_emit_comment(proc, str_lit("get union's tag")); tag_index = ir_emit_load(proc, ir_emit_union_tag_ptr(proc, parent_ptr)); union_data = ir_emit_conv(proc, parent_ptr, t_rawptr); @@ -7220,11 +7220,11 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { next = ir_new_block(proc, nullptr, "typeswitch.next"); case_type = type_of_expr(proc->module->info, cc->list[type_index]); irValue *cond = nullptr; - if (match_type_kind == MatchType_Union) { + if (switch_type_kind == SwitchType_Union) { Type *ut = base_type(type_deref(parent_type)); irValue *variant_tag = ir_const_union_tag(proc->module->allocator, ut, case_type); cond = ir_emit_comp(proc, Token_CmpEq, tag_index, variant_tag); - } else if (match_type_kind == MatchType_Any) { + } else if (switch_type_kind == SwitchType_Any) { irValue *any_ti = ir_emit_load(proc, ir_emit_struct_ep(proc, parent_ptr, 1)); irValue *case_ti = ir_type_info(proc, case_type); cond = ir_emit_comp(proc, Token_CmpEq, any_ti, case_ti); @@ -7250,9 +7250,9 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } GB_ASSERT_MSG(is_type_pointer(ct), "%s", type_to_string(ct)); irValue *data = nullptr; - if (match_type_kind == MatchType_Union) { + if (switch_type_kind == SwitchType_Union) { data = union_data; - } else if (match_type_kind == MatchType_Any) { + } else if (switch_type_kind == SwitchType_Any) { irValue *any_data = ir_emit_load(proc, ir_emit_struct_ep(proc, parent_ptr, 0)); data = any_data; } @@ -8713,7 +8713,7 @@ void ir_gen_tree(irGen *s) { Type *t = type_deref(ir_type(var->var)); if (is_type_any(t)) { - // NOTE(bill): Edge case for `any` type + // NOTE(bill): Edge case for 'any' type Type *var_type = default_type(ir_type(var->init)); irValue *g = ir_add_global_generated(proc->module, var_type, var->init); ir_emit_store(proc, g, var->init); diff --git a/src/main.cpp b/src/main.cpp index d3a705ab0..78fbbf178 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -19,7 +19,7 @@ #include "ir_print.cpp" #if defined(GB_SYSTEM_WINDOWS) -// NOTE(bill): `name` is used in debugging and profiling modes +// NOTE(bill): 'name' is used in debugging and profiling modes i32 system_exec_command_line_app(char *name, bool is_silent, char *fmt, ...) { STARTUPINFOW start_info = {gb_size_of(STARTUPINFOW)}; PROCESS_INFORMATION pi = {0}; @@ -275,7 +275,7 @@ bool parse_build_flags(Array args) { if (bf.name == name) { found = true; if (set_flags[bf.kind]) { - gb_printf_err("Previous flag set: `%.*s`\n", LIT(name)); + gb_printf_err("Previous flag set: '%.*s'\n", LIT(name)); bad_flags = true; } else { ExactValue value = {}; @@ -284,11 +284,11 @@ bool parse_build_flags(Array args) { if (param.len == 0) { ok = true; } else { - gb_printf_err("Flag `%.*s` was not expecting a parameter `%.*s`\n", LIT(name), LIT(param)); + gb_printf_err("Flag '%.*s' was not expecting a parameter '%.*s'\n", LIT(name), LIT(param)); bad_flags = true; } } else if (param.len == 0) { - gb_printf_err("Flag missing for `%.*s`\n", LIT(name)); + gb_printf_err("Flag missing for '%.*s'\n", LIT(name)); bad_flags = true; } else { ok = true; @@ -320,7 +320,7 @@ bool parse_build_flags(Array args) { } else if (param == "0") { value = exact_value_bool(false); } else { - gb_printf_err("Invalid flag parameter for `%.*s` = `%.*s`\n", LIT(name), LIT(param)); + gb_printf_err("Invalid flag parameter for '%.*s' = '%.*s'\n", LIT(name), LIT(param)); } } break; case BuildFlagParam_Integer: @@ -408,20 +408,20 @@ bool parse_build_flags(Array args) { } } if (eq_pos < 0) { - gb_printf_err("Expected `name=path`, got `%.*s`\n", LIT(param)); + gb_printf_err("Expected 'name=path', got '%.*s'\n", LIT(param)); bad_flags = true; break; } String name = substring(str, 0, eq_pos); String path = substring(str, eq_pos+1, str.len); if (name.len == 0 || path.len == 0) { - gb_printf_err("Expected `name=path`, got `%.*s`\n", LIT(param)); + gb_printf_err("Expected 'name=path', got '%.*s'\n", LIT(param)); bad_flags = true; break; } if (!string_is_valid_identifier(name)) { - gb_printf_err("Library collection name `%.*s` must be a valid identifier\n", LIT(name)); + gb_printf_err("Library collection name '%.*s' must be a valid identifier\n", LIT(name)); bad_flags = true; break; } @@ -433,7 +433,7 @@ bool parse_build_flags(Array args) { } if (name == "system") { - gb_printf_err("Library collection name `system` is reserved\n"); + gb_printf_err("Library collection name 'system' is reserved\n"); bad_flags = true; break; } @@ -441,7 +441,7 @@ bool parse_build_flags(Array args) { String prev_path = {}; bool found = find_library_collection_path(name, &prev_path); if (found) { - gb_printf_err("Library collection `%.*s` already exists with path `%.*s`\n", LIT(name), LIT(prev_path)); + gb_printf_err("Library collection '%.*s' already exists with path '%.*s'\n", LIT(name), LIT(prev_path)); bad_flags = true; break; } @@ -449,7 +449,7 @@ bool parse_build_flags(Array args) { gbAllocator a = heap_allocator(); String fullpath = path_to_fullpath(a, path); if (!path_is_directory(fullpath)) { - gb_printf_err("Library collection `%.*s` path must be a directory, got `%.*s`\n", LIT(name), LIT(fullpath)); + gb_printf_err("Library collection '%.*s' path must be a directory, got '%.*s'\n", LIT(name), LIT(fullpath)); gb_free(a, fullpath.text); bad_flags = true; break; @@ -470,7 +470,7 @@ bool parse_build_flags(Array args) { } } if (!found) { - gb_printf_err("Unknown flag: `%.*s`\n", LIT(name)); + gb_printf_err("Unknown flag: '%.*s'\n", LIT(name)); bad_flags = true; } } @@ -552,7 +552,7 @@ int main(int arg_count, char **arg_ptr) { init_global_error_collector(); array_init(&library_collections, heap_allocator()); - // NOTE(bill): `core` cannot be (re)defined by the user + // NOTE(bill): 'core' cannot be (re)defined by the user add_library_collection(str_lit("core"), get_fullpath_relative(heap_allocator(), odin_root_dir(), str_lit("core"))); Array args = setup_args(arg_count, arg_ptr); @@ -606,7 +606,7 @@ int main(int arg_count, char **arg_ptr) { } - // NOTE(bill): add `shared` directory if it is not already set + // NOTE(bill): add 'shared' directory if it is not already set if (!find_library_collection_path(str_lit("shared"), nullptr)) { add_library_collection(str_lit("shared"), get_fullpath_relative(heap_allocator(), odin_root_dir(), str_lit("shared"))); @@ -717,7 +717,7 @@ int main(int arg_count, char **arg_ptr) { #if defined(GB_SYSTEM_OSX) // This sets a requirement of Mountain Lion and up, but the compiler doesn't work without this limit. // NOTE: If you change this (although this minimum is as low as you can go with Odin working) - // make sure to also change the `macosx_version_min` param passed to `llc` + // make sure to also change the 'macosx_version_min' param passed to 'llc' "-mtriple=x86_64-apple-macosx10.8 " #endif "", @@ -844,17 +844,17 @@ int main(int arg_count, char **arg_ptr) { len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " -l%.*s ", LIT(lib)); } #else - // NOTE(vassvik): static libraries (.a files) in linux can be linked to directly using the full path, - // since those are statically linked to at link time. shared libraries (.so) has to be + // NOTE(vassvik): static libraries (.a files) in linux can be linked to directly using the full path, + // since those are statically linked to at link time. shared libraries (.so) has to be // available at runtime wherever the executable is run, so we make require those to be // local to the executable (unless the system collection is used, in which case we search - // the system library paths for the library file). + // the system library paths for the library file). if (string_has_extension(lib, str_lit("a"))) { // static libs, absolute full path relative to the file in which the lib was imported from isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " -l:%.*s ", LIT(lib)); } else if (string_has_extension(lib, str_lit("so"))) { // dynamic lib, relative path to executable - // NOTE(vassvik): it is the user's responsibility to make sure the shared library files are visible + // NOTE(vassvik): it is the user's responsibility to make sure the shared library files are visible // at runtimeto the executable isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " -l:%s/%.*s ", cwd, LIT(lib)); } else { @@ -902,7 +902,7 @@ int main(int arg_count, char **arg_ptr) { #if defined(GB_SYSTEM_OSX) // This sets a requirement of Mountain Lion and up, but the compiler doesn't work without this limit. // NOTE: If you change this (although this minimum is as low as you can go with Odin working) - // make sure to also change the `mtriple` param passed to `opt` + // make sure to also change the 'mtriple' param passed to 'opt' " -macosx_version_min 10.8.0 " // This points the linker to where the entry point is " -e _main " diff --git a/src/parser.cpp b/src/parser.cpp index b6a86a7c0..7f3bd28d7 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -57,7 +57,7 @@ struct AstFile { Array decls; ImportedFileKind file_kind; bool is_global_scope; - Array imports_and_exports; // `import` `using import` `export` + Array imports_and_exports; // 'import' 'using import' 'export' AstNode * curr_proc; @@ -1004,11 +1004,11 @@ AstNode *ast_binary_expr(AstFile *f, Token op, AstNode *left, AstNode *right) { AstNode *result = make_ast_node(f, AstNode_BinaryExpr); if (left == nullptr) { - syntax_error(op, "No lhs expression for binary expression `%.*s`", LIT(op.string)); + syntax_error(op, "No lhs expression for binary expression '%.*s'", LIT(op.string)); left = ast_bad_expr(f, op, op); } if (right == nullptr) { - syntax_error(op, "No rhs expression for binary expression `%.*s`", LIT(op.string)); + syntax_error(op, "No rhs expression for binary expression '%.*s'", LIT(op.string)); right = ast_bad_expr(f, op, op); } @@ -1706,7 +1706,7 @@ Token expect_token(AstFile *f, TokenKind kind) { if (prev.kind != kind) { String c = token_strings[kind]; String p = token_strings[prev.kind]; - syntax_error(f->curr_token, "Expected `%.*s`, got `%.*s`", LIT(c), LIT(p)); + syntax_error(f->curr_token, "Expected '%.*s', got '%.*s'", LIT(c), LIT(p)); if (prev.kind == Token_EOF) { gb_exit(1); } @@ -1720,7 +1720,7 @@ Token expect_token_after(AstFile *f, TokenKind kind, char *msg) { Token prev = f->curr_token; if (prev.kind != kind) { String p = token_strings[prev.kind]; - syntax_error(f->curr_token, "Expected `%.*s` after %s, got `%.*s`", + syntax_error(f->curr_token, "Expected '%.*s' after %s, got '%.*s'", LIT(token_strings[kind]), msg, LIT(p)); @@ -1733,10 +1733,10 @@ Token expect_token_after(AstFile *f, TokenKind kind, char *msg) { Token expect_operator(AstFile *f) { Token prev = f->curr_token; if (!gb_is_between(prev.kind, Token__OperatorBegin+1, Token__OperatorEnd-1)) { - syntax_error(f->curr_token, "Expected an operator, got `%.*s`", + syntax_error(f->curr_token, "Expected an operator, got '%.*s'", LIT(token_strings[prev.kind])); } else if (!f->allow_range && (prev.kind == Token_Ellipsis || prev.kind == Token_HalfClosed)) { - syntax_error(f->curr_token, "Expected an non-range operator, got `%.*s`", + syntax_error(f->curr_token, "Expected an non-range operator, got '%.*s'", LIT(token_strings[prev.kind])); } advance_token(f); @@ -1746,7 +1746,7 @@ Token expect_operator(AstFile *f) { Token expect_keyword(AstFile *f) { Token prev = f->curr_token; if (!gb_is_between(prev.kind, Token__KeywordBegin+1, Token__KeywordEnd-1)) { - syntax_error(f->curr_token, "Expected a keyword, got `%.*s`", + syntax_error(f->curr_token, "Expected a keyword, got '%.*s'", LIT(token_strings[prev.kind])); } advance_token(f); @@ -1837,7 +1837,7 @@ Token expect_closing(AstFile *f, TokenKind kind, String context) { if (f->curr_token.kind != kind && f->curr_token.kind == Token_Semicolon && f->curr_token.string == "\n") { - syntax_error(f->curr_token, "Missing `,` before newline in %.*s", LIT(context)); + syntax_error(f->curr_token, "Missing ',' before newline in %.*s", LIT(context)); advance_token(f); } return expect_token(f, kind); @@ -1926,10 +1926,10 @@ void expect_semicolon(AstFile *f, AstNode *s) { return; } String node_string = ast_node_strings[s->kind]; - syntax_error(prev_token, "Expected `;` after %.*s, got %.*s", + syntax_error(prev_token, "Expected ';' after %.*s, got %.*s", LIT(node_string), LIT(token_strings[prev_token.kind])); } else { - syntax_error(prev_token, "Expected `;`"); + syntax_error(prev_token, "Expected ';'"); } fix_advance_to_next_stmt(f); } @@ -2125,7 +2125,7 @@ AstNode *convert_stmt_to_expr(AstFile *f, AstNode *statement, String kind) { return statement->ExprStmt.expr; } - syntax_error(f->curr_token, "Expected `%.*s`, found a simple statement.", LIT(kind)); + syntax_error(f->curr_token, "Expected '%.*s', found a simple statement.", LIT(kind)); Token end = f->curr_token; if (f->tokens.count < f->curr_token_index) { end = f->tokens[f->curr_token_index+1]; @@ -2264,7 +2264,7 @@ AstNode *parse_operand(AstFile *f, bool lhs) { if (pi != ProcInlining_none) { if (expr->ProcLit.inlining != ProcInlining_none && expr->ProcLit.inlining != pi) { - syntax_error(expr, "You cannot apply both `inline` and `no_inline` to a procedure literal"); + syntax_error(expr, "You cannot apply both 'inline' and 'no_inline' to a procedure literal"); } expr->ProcLit.inlining = pi; } @@ -2409,41 +2409,41 @@ AstNode *parse_operand(AstFile *f, bool lhs) { Token tag = expect_token_after(f, Token_Ident, "#"); if (tag.string == "packed") { if (is_packed) { - syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); } is_packed = true; } else if (tag.string == "ordered") { if (is_ordered) { - syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); } is_ordered = true; } else if (tag.string == "align") { if (align) { - syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); } align = parse_expr(f, true); } else if (tag.string == "raw_union") { if (is_raw_union) { - syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); } is_raw_union = true; } else { - syntax_error(tag, "Invalid struct tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Invalid struct tag '#%.*s'", LIT(tag.string)); } } f->expr_level = prev_level; if (is_packed && is_ordered) { - syntax_error(token, "`#ordered` is not needed with `#packed` which implies ordering"); + syntax_error(token, "'#ordered' is not needed with '#packed' which implies ordering"); } if (is_raw_union && is_packed) { is_packed = false; - syntax_error(token, "`#raw_union` cannot also be `#packed`"); + syntax_error(token, "'#raw_union' cannot also be '#packed'"); } if (is_raw_union && is_ordered) { is_ordered = false; - syntax_error(token, "`#raw_union` cannot also be `#ordered`"); + syntax_error(token, "'#raw_union' cannot also be '#ordered'"); } Token open = expect_token_after(f, Token_OpenBrace, "struct"); @@ -2475,11 +2475,11 @@ AstNode *parse_operand(AstFile *f, bool lhs) { Token tag = expect_token_after(f, Token_Ident, "#"); if (tag.string == "align") { if (align) { - syntax_error(tag, "Duplicate union tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate union tag '#%.*s'", LIT(tag.string)); } align = parse_expr(f, true); } else { - syntax_error(tag, "Invalid union tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Invalid union tag '#%.*s'", LIT(tag.string)); } } @@ -2527,11 +2527,11 @@ AstNode *parse_operand(AstFile *f, bool lhs) { Token tag = expect_token_after(f, Token_Ident, "#"); if (tag.string == "align") { if (align) { - syntax_error(tag, "Duplicate bit_field tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate bit_field tag '#%.*s'", LIT(tag.string)); } align = parse_expr(f, true); } else { - syntax_error(tag, "Invalid bit_field tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Invalid bit_field tag '#%.*s'", LIT(tag.string)); } } @@ -2624,7 +2624,7 @@ AstNode *parse_call_expr(AstFile *f, AstNode *operand) { Token eq = expect_token(f, Token_Eq); if (prefix_ellipsis) { - syntax_error(ellipsis, "`...` must be applied to value rather than the field name"); + syntax_error(ellipsis, "'...' must be applied to value rather than the field name"); } AstNode *value = parse_value(f); @@ -3259,7 +3259,7 @@ AstNode *parse_proc_type(AstFile *f, Token proc_token) { Token token = expect_token(f, Token_String); auto c = string_to_calling_convention(token.string); if (c == ProcCC_Invalid) { - syntax_error(token, "Unknown procedure calling convention: `%.*s`\n", LIT(token.string)); + syntax_error(token, "Unknown procedure calling convention: '%.*s'\n", LIT(token.string)); } else { cc = c; } @@ -3307,7 +3307,7 @@ AstNode *parse_var_type(AstFile *f, bool allow_ellipsis, bool allow_type_token) Token tok = advance_token(f); AstNode *type = parse_type_or_ident(f); if (type == nullptr) { - syntax_error(tok, "variadic field missing type after `...`"); + syntax_error(tok, "variadic field missing type after '...'"); type = ast_bad_expr(f, tok, f->curr_token); } return ast_ellipsis(f, tok, type); @@ -3382,7 +3382,7 @@ u32 parse_field_prefixes(AstFile *f) { break; } if (kind == FieldPrefix_Unknown) { - syntax_error(f->curr_token, "Unknown prefix kind `#%.*s`", LIT(f->curr_token.string)); + syntax_error(f->curr_token, "Unknown prefix kind '#%.*s'", LIT(f->curr_token.string)); advance_token(f); continue; } @@ -3394,10 +3394,10 @@ u32 parse_field_prefixes(AstFile *f) { case FieldPrefix_const: const_count += 1; advance_token(f); break; } } - if (using_count > 1) syntax_error(f->curr_token, "Multiple `using` in this field list"); - if (no_alias_count > 1) syntax_error(f->curr_token, "Multiple `#no_alias` in this field list"); - if (c_vararg_count > 1) syntax_error(f->curr_token, "Multiple `#c_vararg` in this field list"); - if (const_count > 1) syntax_error(f->curr_token, "Multiple `#const` in this field list"); + if (using_count > 1) syntax_error(f->curr_token, "Multiple 'using' in this field list"); + if (no_alias_count > 1) syntax_error(f->curr_token, "Multiple '#no_alias' in this field list"); + if (c_vararg_count > 1) syntax_error(f->curr_token, "Multiple '#c_vararg' in this field list"); + if (const_count > 1) syntax_error(f->curr_token, "Multiple '#const' in this field list"); u32 field_flags = 0; @@ -3410,24 +3410,24 @@ u32 parse_field_prefixes(AstFile *f) { u32 check_field_prefixes(AstFile *f, isize name_count, u32 allowed_flags, u32 set_flags) { if (name_count > 1 && (set_flags&FieldFlag_using)) { - syntax_error(f->curr_token, "Cannot apply `using` to more than one of the same type"); + syntax_error(f->curr_token, "Cannot apply 'using' to more than one of the same type"); set_flags &= ~FieldFlag_using; } if ((allowed_flags&FieldFlag_using) == 0 && (set_flags&FieldFlag_using)) { - syntax_error(f->curr_token, "`using` is not allowed within this field list"); + syntax_error(f->curr_token, "'using' is not allowed within this field list"); set_flags &= ~FieldFlag_using; } if ((allowed_flags&FieldFlag_no_alias) == 0 && (set_flags&FieldFlag_no_alias)) { - syntax_error(f->curr_token, "`#no_alias` is not allowed within this field list"); + syntax_error(f->curr_token, "'#no_alias' is not allowed within this field list"); set_flags &= ~FieldFlag_no_alias; } if ((allowed_flags&FieldFlag_c_vararg) == 0 && (set_flags&FieldFlag_c_vararg)) { - syntax_error(f->curr_token, "`#c_vararg` is not allowed within this field list"); + syntax_error(f->curr_token, "'#c_vararg' is not allowed within this field list"); set_flags &= ~FieldFlag_c_vararg; } if ((allowed_flags&FieldFlag_const) == 0 && (set_flags&FieldFlag_const)) { - syntax_error(f->curr_token, "`$` is not allowed within this field list"); + syntax_error(f->curr_token, "'$' is not allowed within this field list"); set_flags &= ~FieldFlag_const; } return set_flags; @@ -3795,28 +3795,28 @@ AstNode *parse_type_or_ident(AstFile *f) { Token tag = expect_token_after(f, Token_Ident, "#"); if (tag.string == "packed") { if (is_packed) { - syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); } is_packed = true; } else if (tag.string == "ordered") { if (is_ordered) { - syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); } is_ordered = true; } else if (tag.string == "align") { if (align) { - syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); } align = parse_expr(f, true); } else { - syntax_error(tag, "Invalid struct tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Invalid struct tag '#%.*s'", LIT(tag.string)); } } f->expr_level = prev_level; if (is_packed && is_ordered) { - syntax_error(token, "`#ordered` is not needed with `#packed` which implies ordering"); + syntax_error(token, "'#ordered' is not needed with '#packed' which implies ordering"); } Token open = expect_token_after(f, Token_OpenBrace, "struct"); @@ -3904,11 +3904,11 @@ AstNode *parse_type_or_ident(AstFile *f) { Token tag = expect_token_after(f, Token_Ident, "#"); if (tag.string == "align") { if (align) { - syntax_error(tag, "Duplicate bit_field tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Duplicate bit_field tag '#%.*s'", LIT(tag.string)); } align = parse_expr(f, true); } else { - syntax_error(tag, "Invalid bit_field tag `#%.*s`", LIT(tag.string)); + syntax_error(tag, "Invalid bit_field tag '#%.*s'", LIT(tag.string)); } } @@ -4329,7 +4329,7 @@ AstNode *parse_defer_stmt(AstFile *f) { AstNode *stmt = parse_stmt(f); switch (stmt->kind) { case AstNode_EmptyStmt: - syntax_error(token, "Empty statement after defer (e.g. `;`)"); + syntax_error(token, "Empty statement after defer (e.g. ';')"); break; case AstNode_DeferStmt: syntax_error(token, "You cannot defer a defer statement"); @@ -4385,14 +4385,14 @@ AstNode *parse_import_decl(AstFile *f, bool is_using) { } if (!is_using && is_blank_ident(import_name)) { - syntax_error(import_name, "Illegal import name: `_`"); + syntax_error(import_name, "Illegal import name: '_'"); } Token file_path = expect_token_after(f, Token_String, "import"); AstNode *s = nullptr; if (f->curr_proc != nullptr) { - syntax_error(import_name, "You cannot use `import` within a procedure. This must be done at the file scope"); + syntax_error(import_name, "You cannot use 'import' within a procedure. This must be done at the file scope"); s = ast_bad_decl(f, import_name, file_path); } else { s = ast_import_decl(f, token, is_using, file_path, import_name, docs, f->line_comment); @@ -4408,7 +4408,7 @@ AstNode *parse_export_decl(AstFile *f) { Token file_path = expect_token_after(f, Token_String, "export"); AstNode *s = nullptr; if (f->curr_proc != nullptr) { - syntax_error(token, "You cannot use `export` within a procedure. This must be done at the file scope"); + syntax_error(token, "You cannot use 'export' within a procedure. This must be done at the file scope"); s = ast_bad_decl(f, token, file_path); } else { s = ast_export_decl(f, token, file_path, docs, f->line_comment); @@ -4439,7 +4439,7 @@ AstNode *parse_foreign_decl(AstFile *f) { break; } if (is_blank_ident(lib_name)) { - syntax_error(lib_name, "Illegal foreign_library name: `_`"); + syntax_error(lib_name, "Illegal foreign_library name: '_'"); } Token file_path = expect_token(f, Token_String); AstNode *s = nullptr; @@ -4545,7 +4545,7 @@ AstNode *parse_stmt(AstFile *f) { AstNode *decl = nullptr; Array list = parse_lhs_expr_list(f); if (list.count == 0) { - syntax_error(token, "Illegal use of `using` statement"); + syntax_error(token, "Illegal use of 'using' statement"); expect_semicolon(f, nullptr); return ast_bad_stmt(f, token, f->curr_token); } @@ -4558,14 +4558,14 @@ AstNode *parse_stmt(AstFile *f) { if (decl != nullptr && decl->kind == AstNode_ValueDecl) { if (!decl->ValueDecl.is_mutable) { - syntax_error(token, "`using` may only be applied to variable declarations"); + syntax_error(token, "'using' may only be applied to variable declarations"); return decl; } decl->ValueDecl.is_using = true; return decl; } - syntax_error(token, "Illegal use of `using` statement"); + syntax_error(token, "Illegal use of 'using' statement"); return ast_bad_stmt(f, token, f->curr_token); } break; @@ -4644,10 +4644,10 @@ AstNode *parse_stmt(AstFile *f) { } if (tag == "include") { - syntax_error(token, "#include is not a valid import declaration kind. Did you mean `import`?"); + syntax_error(token, "#include is not a valid import declaration kind. Did you mean 'import'?"); s = ast_bad_stmt(f, token, f->curr_token); } else { - syntax_error(token, "Unknown tag directive used: `%.*s`", LIT(tag)); + syntax_error(token, "Unknown tag directive used: '%.*s'", LIT(tag)); s = ast_bad_stmt(f, token, f->curr_token); } @@ -4666,7 +4666,7 @@ AstNode *parse_stmt(AstFile *f) { } syntax_error(token, - "Expected a statement, got `%.*s`", + "Expected a statement, got '%.*s'", LIT(token_strings[token.kind])); fix_advance_to_next_stmt(f); return ast_bad_stmt(f, token, f->curr_token); @@ -4886,7 +4886,7 @@ bool determine_path_from_string(Parser *p, AstNode *node, String base_dir, Strin } if (!is_import_path_valid(file_str)) { - syntax_error(node, "Invalid import path: `%.*s`", LIT(file_str)); + syntax_error(node, "Invalid import path: '%.*s'", LIT(file_str)); return false; } @@ -4901,7 +4901,7 @@ bool determine_path_from_string(Parser *p, AstNode *node, String base_dir, Strin if (collection_name.len > 0) { if (collection_name == "system") { if (node->kind != AstNode_ForeignImportDecl) { - syntax_error(node, "The library collection `system` is restrict for `foreign_library`"); + syntax_error(node, "The library collection 'system' is restrict for 'foreign_library'"); return false; } else { *path = file_str; @@ -4909,7 +4909,7 @@ bool determine_path_from_string(Parser *p, AstNode *node, String base_dir, Strin } } else if (!find_library_collection_path(collection_name, &base_dir)) { // NOTE(bill): It's a naughty name - syntax_error(node, "Unknown library collection: `%.*s`", LIT(collection_name)); + syntax_error(node, "Unknown library collection: '%.*s'", LIT(collection_name)); return false; } } else { @@ -5071,7 +5071,7 @@ ParseFileError parse_import(Parser *p, ImportedFile imported_file) { gb_printf_err("Failed to parse file: %.*s\n\t", LIT(import_rel_path)); switch (err) { case ParseFile_WrongExtension: - gb_printf_err("Invalid file extension: File must have the extension `.odin`"); + gb_printf_err("Invalid file extension: File must have the extension '.odin'"); break; case ParseFile_InvalidFile: gb_printf_err("Invalid file or cannot be found"); @@ -5080,7 +5080,7 @@ ParseFileError parse_import(Parser *p, ImportedFile imported_file) { gb_printf_err("File permissions problem"); break; case ParseFile_NotFound: - gb_printf_err("File cannot be found (`%.*s`)", LIT(import_path)); + gb_printf_err("File cannot be found ('%.*s')", LIT(import_path)); break; case ParseFile_InvalidToken: gb_printf_err("Invalid token found in file at (%td:%td)", err_pos.line, err_pos.column);