From a5809d0185dfeb2473f2a3947459b889c4dd5098 Mon Sep 17 00:00:00 2001 From: Krzesimir Nowak Date: Thu, 18 Dec 2025 15:04:22 +0100 Subject: Fix #packed #all_or_none --- src/parser.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/parser.cpp') diff --git a/src/parser.cpp b/src/parser.cpp index 06703d643..de5655ce1 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -2803,7 +2803,7 @@ gb_internal Ast *parse_operand(AstFile *f, bool lhs) { } is_packed = true; } else if (tag.string == "all_or_none") { - if (is_packed) { + if (is_all_or_none) { syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); } is_all_or_none = true; -- cgit v1.2.3 From 2e6554b8c85c904eb1eb010f0312641be800823f Mon Sep 17 00:00:00 2001 From: gingerBill Date: Fri, 26 Dec 2025 11:49:46 +0000 Subject: Disallow importing directories with an `.odin` extension/suffix --- src/parser.cpp | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/parser.cpp') diff --git a/src/parser.cpp b/src/parser.cpp index de5655ce1..b2ff55396 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -5818,6 +5818,11 @@ gb_internal AstPackage *try_add_import_path(Parser *p, String path, String const return nullptr; } + if (string_ends_with(path, str_lit(".odin"))) { + error(pos, "'import' declarations cannot import directories with a .odin extension/suffix"); + return nullptr; + } + isize files_with_ext = 0; isize files_to_reserve = 1; // always reserve 1 for (FileInfo fi : list) { -- cgit v1.2.3 From 0bf4ffe46943f8f8bfe2f4f077c92be1512d117a Mon Sep 17 00:00:00 2001 From: Krzesimir Nowak Date: Mon, 29 Dec 2025 18:39:31 +0100 Subject: Fix handling of #force_inline --- src/parser.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'src/parser.cpp') diff --git a/src/parser.cpp b/src/parser.cpp index b2ff55396..823021e04 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -2183,7 +2183,7 @@ gb_internal Ast *parse_force_inlining_operand(AstFile *f, Token token) { return expr; } if (e->kind != Ast_ProcLit && e->kind != Ast_CallExpr) { - syntax_error(expr, "%.*s must be followed by a procedure literal or call, got %.*s", LIT(token.string), LIT(ast_strings[expr->kind])); + syntax_error(expr, "%.*s must be followed by a procedure literal or call, got %.*s", LIT(token.string), LIT(ast_strings[e->kind])); return ast_bad_expr(f, token, f->curr_token); } ProcInlining pi = ProcInlining_none; @@ -2197,17 +2197,17 @@ gb_internal Ast *parse_force_inlining_operand(AstFile *f, Token token) { if (pi != ProcInlining_none) { if (e->kind == Ast_ProcLit) { - if (expr->ProcLit.inlining != ProcInlining_none && - expr->ProcLit.inlining != pi) { + if (e->ProcLit.inlining != ProcInlining_none && + e->ProcLit.inlining != pi) { syntax_error(expr, "Cannot apply both '#force_inline' and '#force_no_inline' to a procedure literal"); } - expr->ProcLit.inlining = pi; + e->ProcLit.inlining = pi; } else if (e->kind == Ast_CallExpr) { - if (expr->CallExpr.inlining != ProcInlining_none && - expr->CallExpr.inlining != pi) { + if (e->CallExpr.inlining != ProcInlining_none && + e->CallExpr.inlining != pi) { syntax_error(expr, "Cannot apply both '#force_inline' and '#force_no_inline' to a procedure call"); } - expr->CallExpr.inlining = pi; + e->CallExpr.inlining = pi; } } -- cgit v1.2.3 From 0366cd3304b3910a397c4989e46bee4c575adeec Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 15 Jan 2026 16:32:52 +0000 Subject: Add `#must_tail` (similar syntax to `#force_inline` --- src/check_expr.cpp | 30 ++++++++++++++++++++++++++--- src/llvm_backend.cpp | 12 ++++++------ src/llvm_backend.hpp | 3 ++- src/llvm_backend_proc.cpp | 48 +++++++++++++++++++++++++++++++++++++++++------ src/parser.cpp | 23 ++++++++++++++++++----- src/parser.hpp | 13 ++++++++++--- 6 files changed, 105 insertions(+), 24 deletions(-) (limited to 'src/parser.cpp') diff --git a/src/check_expr.cpp b/src/check_expr.cpp index cd2307c6d..3b470cb88 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -8210,7 +8210,7 @@ gb_internal void check_objc_call_expr(CheckerContext *c, Operand *operand, Ast * add_objc_proc_type(c, call, return_type, param_types); } -gb_internal ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *call, Ast *proc, Slice const &args, ProcInlining inlining, Type *type_hint) { +gb_internal ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *call, Ast *proc, Slice const &args, ProcInlining inlining, ProcTailing tailing, Type *type_hint) { if (proc != nullptr && proc->kind == Ast_BasicDirective) { ast_node(bd, BasicDirective, proc); @@ -8241,7 +8241,10 @@ gb_internal ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *c return Expr_Expr; } if (inlining != ProcInlining_none) { - error(call, "Inlining operators are not allowed on built-in procedures"); + error(call, "Inlining directives are not allowed on built-in procedures"); + } + if (tailing != ProcTailing_none) { + error(call, "Tailing directives are not allowed on built-in procedures"); } } else { if (proc != nullptr) { @@ -8383,6 +8386,7 @@ gb_internal ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *c } bool is_call_inlined = false; + bool is_call_tailed = true; switch (inlining) { case ProcInlining_inline: @@ -8417,6 +8421,20 @@ gb_internal ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *c } } + switch (tailing) { + case ProcTailing_none: + break; + case ProcTailing_must_tail: + is_call_tailed = true; + if (proc != nullptr) { + Entity *e = entity_from_expr(proc); + if (e != nullptr && e->kind == Entity_Procedure) { + // TODO(bill): `preserve_none` + } + } + break; + } + { String invalid; if (pt->kind == Type_Proc && pt->Proc.require_target_feature.len != 0) { @@ -11825,7 +11843,7 @@ gb_internal ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast case_end; case_ast_node(ce, CallExpr, node); - return check_call_expr(c, o, node, ce->proc, ce->args, ce->inlining, type_hint); + return check_call_expr(c, o, node, ce->proc, ce->args, ce->inlining, ce->tailing, type_hint); case_end; case_ast_node(de, DerefExpr, node); @@ -12566,6 +12584,12 @@ gb_internal gbString write_expr_to_string(gbString str, Ast *node, bool shorthan case_end; case_ast_node(ce, CallExpr, node); + switch (ce->tailing) { + case ProcTailing_must_tail: + str = gb_string_appendc(str, "#must_tail "); + break; + } + switch (ce->inlining) { case ProcInlining_inline: str = gb_string_appendc(str, "#force_inline "); diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index 1cde65640..0bf3d1125 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -2111,7 +2111,7 @@ gb_internal void lb_create_startup_runtime_generate_body(lbModule *m, lbProcedur for (Entity *e : info->init_procedures) { lbValue value = lb_find_procedure_value_from_entity(m, e); - lb_emit_call(p, value, {}, ProcInlining_none); + lb_emit_call(p, value, {}, ProcInlining_none, ProcTailing_none); } @@ -2157,7 +2157,7 @@ gb_internal lbProcedure *lb_create_cleanup_runtime(lbModule *main_module) { // C for (Entity *e : info->fini_procedures) { lbValue value = lb_find_procedure_value_from_entity(main_module, e); - lb_emit_call(p, value, {}, ProcInlining_none); + lb_emit_call(p, value, {}, ProcInlining_none, ProcTailing_none); } lb_end_procedure_body(p); @@ -2850,7 +2850,7 @@ gb_internal lbProcedure *lb_create_main_procedure(lbModule *m, lbProcedure *star } lbValue startup_runtime_value = {startup_runtime->value, startup_runtime->type}; - lb_emit_call(p, startup_runtime_value, {}, ProcInlining_none); + lb_emit_call(p, startup_runtime_value, {}, ProcInlining_none, ProcTailing_none); if (build_context.command_kind == Command_test) { Type *t_Internal_Test = find_type_in_pkg(m->info, str_lit("testing"), str_lit("Internal_Test")); @@ -2917,16 +2917,16 @@ gb_internal lbProcedure *lb_create_main_procedure(lbModule *m, lbProcedure *star auto exit_args = array_make(temporary_allocator(), 1); exit_args[0] = lb_emit_select(p, result, lb_const_int(m, t_int, 0), lb_const_int(m, t_int, 1)); - lb_emit_call(p, exit_runner, exit_args, ProcInlining_none); + lb_emit_call(p, exit_runner, exit_args, ProcInlining_none, ProcTailing_none); } else { if (m->info->entry_point != nullptr) { lbValue entry_point = lb_find_procedure_value_from_entity(m, m->info->entry_point); - lb_emit_call(p, entry_point, {}, ProcInlining_no_inline); + lb_emit_call(p, entry_point, {}, ProcInlining_no_inline, ProcTailing_none); } if (call_cleanup) { lbValue cleanup_runtime_value = {cleanup_runtime->value, cleanup_runtime->type}; - lb_emit_call(p, cleanup_runtime_value, {}, ProcInlining_none); + lb_emit_call(p, cleanup_runtime_value, {}, ProcInlining_none, ProcTailing_none); } if (is_dll_main) { diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp index da5d91f2e..9db7e94d9 100644 --- a/src/llvm_backend.hpp +++ b/src/llvm_backend.hpp @@ -345,6 +345,7 @@ struct lbProcedure { Ast * body; u64 tags; ProcInlining inlining; + ProcTailing tailing; bool is_foreign; bool is_export; bool is_entry_point; @@ -484,7 +485,7 @@ gb_internal void lb_emit_defer_stmts(lbProcedure *p, lbDeferExitKind kind, lbBlo gb_internal void lb_emit_defer_stmts(lbProcedure *p, lbDeferExitKind kind, lbBlock *block, Ast *node); gb_internal lbValue lb_emit_transmute(lbProcedure *p, lbValue value, Type *t); gb_internal lbValue lb_emit_comp(lbProcedure *p, TokenKind op_kind, lbValue left, lbValue right); -gb_internal lbValue lb_emit_call(lbProcedure *p, lbValue value, Array const &args, ProcInlining inlining = ProcInlining_none); +gb_internal lbValue lb_emit_call(lbProcedure *p, lbValue value, Array const &args, ProcInlining inlining = ProcInlining_none, ProcTailing tailing = ProcTailing_none); gb_internal lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t); gb_internal lbValue lb_emit_comp_against_nil(lbProcedure *p, TokenKind op_kind, lbValue x); diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp index 216d600da..0703941c1 100644 --- a/src/llvm_backend_proc.cpp +++ b/src/llvm_backend_proc.cpp @@ -117,6 +117,7 @@ gb_internal lbProcedure *lb_create_procedure(lbModule *m, Entity *entity, bool i p->type_expr = decl->type_expr; p->body = pl->body; p->inlining = pl->inlining; + p->tailing = pl->tailing; p->is_foreign = entity->Procedure.is_foreign; p->is_export = entity->Procedure.is_export; p->is_entry_point = false; @@ -178,6 +179,12 @@ gb_internal lbProcedure *lb_create_procedure(lbModule *m, Entity *entity, bool i } } + switch (p->tailing) { + case ProcTailing_must_tail: + lb_add_attribute_to_proc(m, p->value, "preserve_none"); + break; + } + switch (entity->Procedure.optimization_mode) { case ProcedureOptimizationMode_None: lb_add_attribute_to_proc(m, p->value, "optnone"); @@ -387,6 +394,7 @@ gb_internal lbProcedure *lb_create_dummy_procedure(lbModule *m, String link_name p->body = nullptr; p->tags = 0; p->inlining = ProcInlining_none; + p->tailing = ProcTailing_none; p->is_foreign = false; p->is_export = false; p->is_entry_point = false; @@ -855,7 +863,7 @@ gb_internal Array lb_value_to_array(lbProcedure *p, gbAllocator const & -gb_internal lbValue lb_emit_call_internal(lbProcedure *p, lbValue value, lbValue return_ptr, Array const &processed_args, Type *abi_rt, lbAddr context_ptr, ProcInlining inlining) { +gb_internal lbValue lb_emit_call_internal(lbProcedure *p, lbValue value, lbValue return_ptr, Array const &processed_args, Type *abi_rt, lbAddr context_ptr, ProcInlining inlining, ProcTailing tailing) { GB_ASSERT(p->module->ctx == LLVMGetTypeContext(LLVMTypeOf(value.value))); unsigned arg_count = cast(unsigned)processed_args.count; @@ -972,6 +980,15 @@ gb_internal lbValue lb_emit_call_internal(lbProcedure *p, lbValue value, lbValue break; } + switch (tailing) { + case ProcTailing_none: + break; + case ProcTailing_must_tail: + LLVMSetTailCall(ret, true); + LLVMSetTailCallKind(ret, LLVMTailCallKindMustTail); + break; + } + lbValue res = {}; res.value = ret; res.type = abi_rt; @@ -1045,7 +1062,7 @@ gb_internal lbValue lb_emit_conjugate(lbProcedure *p, lbValue val, Type *type) { return lb_emit_load(p, res); } -gb_internal lbValue lb_emit_call(lbProcedure *p, lbValue value, Array const &args, ProcInlining inlining) { +gb_internal lbValue lb_emit_call(lbProcedure *p, lbValue value, Array const &args, ProcInlining inlining, ProcTailing tailing) { lbModule *m = p->module; Type *pt = base_type(value.type); @@ -1168,10 +1185,10 @@ gb_internal lbValue lb_emit_call(lbProcedure *p, lbValue value, Array c if (return_by_pointer) { lbValue return_ptr = lb_add_local_generated(p, rt, true).addr; - lb_emit_call_internal(p, value, return_ptr, processed_args, nullptr, context_ptr, inlining); + lb_emit_call_internal(p, value, return_ptr, processed_args, nullptr, context_ptr, inlining, tailing); result = lb_emit_load(p, return_ptr); } else if (rt != nullptr) { - result = lb_emit_call_internal(p, value, {}, processed_args, rt, context_ptr, inlining); + result = lb_emit_call_internal(p, value, {}, processed_args, rt, context_ptr, inlining, tailing); if (ft->ret.cast_type) { result.value = OdinLLVMBuildTransmute(p, result.value, ft->ret.cast_type); } @@ -1184,7 +1201,7 @@ gb_internal lbValue lb_emit_call(lbProcedure *p, lbValue value, Array c result = lb_emit_conv(p, result, rt); } } else { - lb_emit_call_internal(p, value, {}, processed_args, nullptr, context_ptr, inlining); + lb_emit_call_internal(p, value, {}, processed_args, nullptr, context_ptr, inlining, tailing); } if (original_rt != rt) { @@ -4402,6 +4419,25 @@ gb_internal lbValue lb_build_call_expr_internal(lbProcedure *p, Ast *expr) { return lb_handle_objc_auto_send(p, expr, slice(call_args, 0, call_args.count)); } - return lb_emit_call(p, value, call_args, ce->inlining); + + ProcInlining inlining = ce->inlining; + ProcTailing tailing = ce->tailing; + + if (tailing == ProcTailing_none && + proc_entity && proc_entity->kind == Entity_Procedure && + proc_entity->decl_info && + proc_entity->decl_info->proc_lit) { + ast_node(pl, ProcLit, proc_entity->decl_info->proc_lit); + + if (pl->inlining != ProcInlining_none) { + inlining = pl->inlining; + } + + if (pl->tailing != ProcTailing_none) { + tailing = pl->tailing; + } + } + + return lb_emit_call(p, value, call_args, inlining, tailing); } diff --git a/src/parser.cpp b/src/parser.cpp index 823021e04..d8a9df473 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -2176,7 +2176,7 @@ gb_internal bool ast_on_same_line(Token const &x, Ast *yp) { return x.pos.line == y.pos.line; } -gb_internal Ast *parse_force_inlining_operand(AstFile *f, Token token) { +gb_internal Ast *parse_inlining_or_tailing_operand(AstFile *f, Token token) { Ast *expr = parse_unary_expr(f, false); Ast *e = strip_or_return_expr(expr); if (e == nullptr) { @@ -2187,11 +2187,14 @@ gb_internal Ast *parse_force_inlining_operand(AstFile *f, Token token) { return ast_bad_expr(f, token, f->curr_token); } ProcInlining pi = ProcInlining_none; + ProcTailing pt = ProcTailing_none; if (token.kind == Token_Ident) { if (token.string == "force_inline") { pi = ProcInlining_inline; } else if (token.string == "force_no_inline") { pi = ProcInlining_no_inline; + } else if (token.string == "must_tail") { + pt = ProcTailing_must_tail; } } @@ -2211,6 +2214,14 @@ gb_internal Ast *parse_force_inlining_operand(AstFile *f, Token token) { } } + if (pt != ProcTailing_none) { + if (e->kind == Ast_ProcLit) { + e->ProcLit.tailing = pt; + } else if (e->kind == Ast_CallExpr) { + e->CallExpr.tailing = pt; + } + } + return expr; } @@ -2507,8 +2518,9 @@ gb_internal Ast *parse_operand(AstFile *f, bool lhs) { syntax_error(tag, "#relative types have now been removed in favour of \"core:relative\""); return ast_relative_type(f, tag, type); } else if (name.string == "force_inline" || - name.string == "force_no_inline") { - return parse_force_inlining_operand(f, name); + name.string == "force_no_inline" || + name.string == "must_tail") { + return parse_inlining_or_tailing_operand(f, name); } return ast_basic_directive(f, token, name); } @@ -5399,8 +5411,9 @@ gb_internal Ast *parse_stmt(AstFile *f) { expect_semicolon(f); return stmt; } else if (name.string == "force_inline" || - name.string == "force_no_inline") { - Ast *expr = parse_force_inlining_operand(f, name); + name.string == "force_no_inline" || + name.string == "must_tail") { + Ast *expr = parse_inlining_or_tailing_operand(f, name); Ast *stmt = ast_expr_stmt(f, expr); expect_semicolon(f); return stmt; diff --git a/src/parser.hpp b/src/parser.hpp index 71b61d95f..30b11c730 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -263,12 +263,17 @@ struct ForeignFileWorkerData { -enum ProcInlining { - ProcInlining_none = 0, - ProcInlining_inline = 1, +enum ProcInlining : u8 { + ProcInlining_none = 0, + ProcInlining_inline = 1, ProcInlining_no_inline = 2, }; +enum ProcTailing : u8 { + ProcTailing_none = 0, + ProcTailing_must_tail = 1, +}; + enum ProcTag { ProcTag_bounds_check = 1<<0, ProcTag_no_bounds_check = 1<<1, @@ -441,6 +446,7 @@ struct AstSplitArgs { Ast *body; \ u64 tags; \ ProcInlining inlining; \ + ProcTailing tailing; \ Token where_token; \ Slice where_clauses; \ DeclInfo *decl; \ @@ -486,6 +492,7 @@ AST_KIND(_ExprBegin, "", bool) \ Token close; \ Token ellipsis; \ ProcInlining inlining; \ + ProcTailing tailing; \ bool optional_ok_one; \ bool was_selector; \ AstSplitArgs *split_args; \ -- cgit v1.2.3 From 5f07055ac1548e6254651f40a23e74093a9bebfe Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 15 Jan 2026 17:28:28 +0000 Subject: Add `#must_tail` and `"preserve/none"` calling convention --- src/check_expr.cpp | 13 ++++++++----- src/llvm_backend.hpp | 3 +++ src/llvm_backend_proc.cpp | 6 ------ src/parser.cpp | 3 +++ src/parser.hpp | 2 ++ src/types.cpp | 38 +++++--------------------------------- 6 files changed, 21 insertions(+), 44 deletions(-) (limited to 'src/parser.cpp') diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 3b470cb88..74ae02f94 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -8426,11 +8426,14 @@ gb_internal ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *c break; case ProcTailing_must_tail: is_call_tailed = true; - if (proc != nullptr) { - Entity *e = entity_from_expr(proc); - if (e != nullptr && e->kind == Entity_Procedure) { - // TODO(bill): `preserve_none` - } + if (c->curr_proc_sig == nullptr || !are_types_identical(c->curr_proc_sig, pt)) { + ERROR_BLOCK(); + gbString a = type_to_string(pt); + gbString b = type_to_string(c->curr_proc_sig); + error(call, "Use of '#must_tail' of a procedure must have the same type as the procedure it was called within"); + error_line("\tCall type: %s, parent type: %s", a, b); + gb_string_free(b); + gb_string_free(a); } break; } diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp index 9db7e94d9..884b87998 100644 --- a/src/llvm_backend.hpp +++ b/src/llvm_backend.hpp @@ -671,6 +671,7 @@ enum lbCallingConventionKind : unsigned { lbCallingConvention_PreserveAll = 15, lbCallingConvention_Swift = 16, lbCallingConvention_CXX_FAST_TLS = 17, + lbCallingConvention_PreserveNone = 21, lbCallingConvention_FirstTargetCC = 64, lbCallingConvention_X86_StdCall = 64, lbCallingConvention_X86_FastCall = 65, @@ -724,6 +725,8 @@ lbCallingConventionKind const lb_calling_convention_map[ProcCC_MAX] = { lbCallingConvention_Win64, // ProcCC_Win64, lbCallingConvention_X86_64_SysV, // ProcCC_SysV, + lbCallingConvention_PreserveNone, // ProcCC_PreserveNone, + }; enum : LLVMDWARFTypeEncoding { diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp index 0703941c1..9ac51bba3 100644 --- a/src/llvm_backend_proc.cpp +++ b/src/llvm_backend_proc.cpp @@ -179,12 +179,6 @@ gb_internal lbProcedure *lb_create_procedure(lbModule *m, Entity *entity, bool i } } - switch (p->tailing) { - case ProcTailing_must_tail: - lb_add_attribute_to_proc(m, p->value, "preserve_none"); - break; - } - switch (entity->Procedure.optimization_mode) { case ProcedureOptimizationMode_None: lb_add_attribute_to_proc(m, p->value, "optnone"); diff --git a/src/parser.cpp b/src/parser.cpp index d8a9df473..8782b3a2b 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -2216,6 +2216,7 @@ gb_internal Ast *parse_inlining_or_tailing_operand(AstFile *f, Token token) { if (pt != ProcTailing_none) { if (e->kind == Ast_ProcLit) { + syntax_error(expr, "'#must_call' can only be applied to a procedure call, not the procedure literal"); e->ProcLit.tailing = pt; } else if (e->kind == Ast_CallExpr) { e->CallExpr.tailing = pt; @@ -4020,6 +4021,8 @@ gb_internal ProcCallingConvention string_to_calling_convention(String const &s) if (s == "win64") return ProcCC_Win64; if (s == "sysv") return ProcCC_SysV; + if (s == "preserve/none") return ProcCC_PreserveNone; + if (s == "system") { if (build_context.metrics.os == TargetOs_windows) { return ProcCC_StdCall; diff --git a/src/parser.hpp b/src/parser.hpp index 30b11c730..77d38b291 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -301,6 +301,7 @@ enum ProcCallingConvention : i32 { ProcCC_Win64 = 9, ProcCC_SysV = 10, + ProcCC_PreserveNone = 11, ProcCC_MAX, @@ -320,6 +321,7 @@ gb_global char const *proc_calling_convention_strings[ProcCC_MAX] = { "inlineasm", "win64", "sysv", + "preserve/none", }; gb_internal ProcCallingConvention default_calling_convention(void) { diff --git a/src/types.cpp b/src/types.cpp index 18e3b56ac..911cd4448 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -5210,40 +5210,12 @@ gb_internal gbString write_type_to_string(gbString str, Type *type, bool shortha case Type_Proc: str = gb_string_appendc(str, "proc"); - switch (type->Proc.calling_convention) { - case ProcCC_Odin: - if (default_calling_convention() != ProcCC_Odin) { - str = gb_string_appendc(str, " \"odin\" "); - } - break; - case ProcCC_Contextless: - if (default_calling_convention() != ProcCC_Contextless) { - str = gb_string_appendc(str, " \"contextless\" "); - } - break; - case ProcCC_CDecl: - str = gb_string_appendc(str, " \"c\" "); - break; - case ProcCC_StdCall: - str = gb_string_appendc(str, " \"std\" "); - break; - case ProcCC_FastCall: - str = gb_string_appendc(str, " \"fastcall\" "); - break; - break; - case ProcCC_None: - str = gb_string_appendc(str, " \"none\" "); - break; - case ProcCC_Naked: - str = gb_string_appendc(str, " \"naked\" "); - break; - // case ProcCC_VectorCall: - // str = gb_string_appendc(str, " \"vectorcall\" "); - // break; - // case ProcCC_ClrCall: - // str = gb_string_appendc(str, " \"clrcall\" "); - // break; + if (type->Proc.calling_convention != default_calling_convention()) { + str = gb_string_appendc(str, " \""); + str = gb_string_appendc(str, proc_calling_convention_strings[type->Proc.calling_convention]); + str = gb_string_appendc(str, "\" "); } + str = gb_string_appendc(str, "("); if (type->Proc.params) { str = write_type_to_string(str, type->Proc.params, shorthand, allow_polymorphic); -- cgit v1.2.3 From 59ae82634ed69b019a8965d1120dd8c7c5a7a605 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 15 Jan 2026 17:52:36 +0000 Subject: Add `preserve/most` and `preserve/all` --- src/llvm_backend.hpp | 2 ++ src/parser.cpp | 2 ++ src/parser.hpp | 4 ++++ 3 files changed, 8 insertions(+) (limited to 'src/parser.cpp') diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp index 884b87998..e10471527 100644 --- a/src/llvm_backend.hpp +++ b/src/llvm_backend.hpp @@ -726,6 +726,8 @@ lbCallingConventionKind const lb_calling_convention_map[ProcCC_MAX] = { lbCallingConvention_X86_64_SysV, // ProcCC_SysV, lbCallingConvention_PreserveNone, // ProcCC_PreserveNone, + lbCallingConvention_PreserveMost, // ProcCC_PreserveMost, + lbCallingConvention_PreserveAll, // ProcCC_PreserveAll, }; diff --git a/src/parser.cpp b/src/parser.cpp index 8782b3a2b..fc55dae97 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -4022,6 +4022,8 @@ gb_internal ProcCallingConvention string_to_calling_convention(String const &s) if (s == "sysv") return ProcCC_SysV; if (s == "preserve/none") return ProcCC_PreserveNone; + if (s == "preserve/most") return ProcCC_PreserveMost; + if (s == "preserve/all") return ProcCC_PreserveAll; if (s == "system") { if (build_context.metrics.os == TargetOs_windows) { diff --git a/src/parser.hpp b/src/parser.hpp index 77d38b291..011330438 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -302,6 +302,8 @@ enum ProcCallingConvention : i32 { ProcCC_SysV = 10, ProcCC_PreserveNone = 11, + ProcCC_PreserveMost = 12, + ProcCC_PreserveAll = 13, ProcCC_MAX, @@ -322,6 +324,8 @@ gb_global char const *proc_calling_convention_strings[ProcCC_MAX] = { "win64", "sysv", "preserve/none", + "preserve/most", + "preserve/all", }; gb_internal ProcCallingConvention default_calling_convention(void) { -- cgit v1.2.3 From ce71227b6bba4bbe74d53c681264a9cba974403a Mon Sep 17 00:00:00 2001 From: Jeroen van Rijn Date: Thu, 22 Jan 2026 15:20:39 +0100 Subject: Fix #6130 --- src/parser.cpp | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/parser.cpp') diff --git a/src/parser.cpp b/src/parser.cpp index fc55dae97..277a405b7 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -5071,6 +5071,10 @@ gb_internal Ast *parse_import_decl(AstFile *f, ImportDeclKind kind) { syntax_error(import_name, "'using import' is not allowed, please use the import name explicitly"); } + if (file_path.string == "\".\"") { + syntax_error(import_name, "Cannot cyclicly import packages"); + } + expect_semicolon(f); return s; } -- cgit v1.2.3 From a9a65b5377e8146edc35040a1faedd38c425d6cf Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Sat, 24 Jan 2026 12:59:55 +0100 Subject: make #+vet tags always work in addition to command line flags --- src/parser.cpp | 28 ++++++++-------------------- 1 file changed, 8 insertions(+), 20 deletions(-) (limited to 'src/parser.cpp') diff --git a/src/parser.cpp b/src/parser.cpp index 277a405b7..91ee0ba22 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -6363,14 +6363,12 @@ gb_internal u64 parse_vet_tag(Token token_for_pos, String s) { GB_ASSERT(string_starts_with(s, prefix)); s = string_trim_whitespace(substring(s, prefix.len, s.len)); + u64 vet_flags = build_context.vet_flags; + if (s.len == 0) { - return VetFlag_All; + vet_flags |= VetFlag_All; } - - u64 vet_flags = 0; - u64 vet_not_flags = 0; - while (s.len > 0) { String p = string_trim_whitespace(vet_tag_get_token(s, &s, /*allow_colon*/false)); if (p.len == 0) { @@ -6383,16 +6381,16 @@ gb_internal u64 parse_vet_tag(Token token_for_pos, String s) { p = substring(p, 1, p.len); if (p.len == 0) { syntax_error(token_for_pos, "Expected a vet flag name after '!'"); - return build_context.vet_flags; + return vet_flags; } } u64 flag = get_vet_flag_from_name(p); if (flag != VetFlag_NONE) { if (is_notted) { - vet_not_flags |= flag; + vet_flags = vet_flags &~ flag; } else { - vet_flags |= flag; + vet_flags |= flag; } } else { ERROR_BLOCK(); @@ -6410,21 +6408,11 @@ gb_internal u64 parse_vet_tag(Token token_for_pos, String s) { error_line("\tcast\n"); error_line("\ttabs\n"); error_line("\texplicit-allocators\n"); - return build_context.vet_flags; + return vet_flags; } } - if (vet_flags == 0 && vet_not_flags == 0) { - return build_context.vet_flags; - } - if (vet_flags == 0 && vet_not_flags != 0) { - return build_context.vet_flags &~ vet_not_flags; - } - if (vet_flags != 0 && vet_not_flags == 0) { - return vet_flags; - } - GB_ASSERT(vet_flags != 0 && vet_not_flags != 0); - return vet_flags &~ vet_not_flags; + return vet_flags; } gb_internal u64 parse_feature_tag(Token token_for_pos, String s) { -- cgit v1.2.3 From 1c529d8cb217cc97138934f393b5670e16fd1843 Mon Sep 17 00:00:00 2001 From: Jeroen van Rijn Date: Sat, 24 Jan 2026 14:06:31 +0100 Subject: Fix #6165 --- src/parser.cpp | 6 ++++++ tests/issues/run.bat | 1 + tests/issues/run.sh | 2 +- tests/issues/test_issue_6165.odin | 13 +++++++++++++ 4 files changed, 21 insertions(+), 1 deletion(-) create mode 100644 tests/issues/test_issue_6165.odin (limited to 'src/parser.cpp') diff --git a/src/parser.cpp b/src/parser.cpp index 277a405b7..fe864a6bc 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -6023,6 +6023,12 @@ gb_internal bool determine_path_from_string(BlockingMutex *file_mutex, Ast *node has_windows_drive = true; } } + + for (isize i = 0; i < original_string.len; i++) { + if (original_string.text[i] == '\\') { + original_string.text[i] = '/'; + } + } } #endif diff --git a/tests/issues/run.bat b/tests/issues/run.bat index 9106a339b..f17f646a6 100644 --- a/tests/issues/run.bat +++ b/tests/issues/run.bat @@ -28,6 +28,7 @@ set COMMON=-define:ODIN_TEST_FANCY=false -file -vet -strict-style -ignore-unused ..\..\..\odin test ..\test_issue_5699.odin %COMMON% || exit /b ..\..\..\odin test ..\test_issue_6068.odin %COMMON% || exit /b ..\..\..\odin test ..\test_issue_6101.odin %COMMON% || exit /b +..\..\..\odin test ..\test_issue_6165.odin %COMMON% || exit /b @echo off diff --git a/tests/issues/run.sh b/tests/issues/run.sh index 58382c7ad..73d0d9587 100755 --- a/tests/issues/run.sh +++ b/tests/issues/run.sh @@ -35,7 +35,7 @@ $ODIN build ../test_issue_5265.odin $COMMON $ODIN test ../test_issue_5699.odin $COMMON $ODIN test ../test_issue_6068.odin $COMMON $ODIN test ../test_issue_6101.odin $COMMON - +$ODIN test ../test_issue_6165.odin $COMMON set +x popd diff --git a/tests/issues/test_issue_6165.odin b/tests/issues/test_issue_6165.odin new file mode 100644 index 000000000..b16995f0e --- /dev/null +++ b/tests/issues/test_issue_6165.odin @@ -0,0 +1,13 @@ +// Tests issue #6165 https://github.com/odin-lang/Odin/issues/6165 +package test_issues + +import "core:testing" + +@(test) +test_issue_6165 :: proc(t: ^testing.T) { + TXT :: #load(ODIN_ROOT + "LICENSE") + + // We don't really care about the length. The test is whether this compiles, or + // if the compiler says it can't find the file we know to exist. + assert(len(TXT) > 0) +} \ No newline at end of file -- cgit v1.2.3 From 83a10e929f634dad2f7e2542ec18d90f73a8925c Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 26 Jan 2026 10:49:24 +0000 Subject: Require space after the prefix of `#+build` style tags --- src/parser.cpp | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) (limited to 'src/parser.cpp') diff --git a/src/parser.cpp b/src/parser.cpp index c1a7fe0ff..af533d9a3 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -6238,9 +6238,28 @@ gb_internal String build_tag_get_token(String s, String *out) { return s; } +// returns true on failure +gb_internal bool build_require_space_after(String s, String prefix) { + GB_ASSERT(string_starts_with(s, prefix)); + + if (s.len == prefix.len) { + return false; + } + String stripped = string_trim_whitespace(substring(s, prefix.len, s.len)); + + if (s[prefix.len] != ' ' && stripped.len != 0) { + return true; + } + return false; +} + gb_internal bool parse_build_tag(Token token_for_pos, String s) { String const prefix = str_lit("build"); GB_ASSERT(string_starts_with(s, prefix)); + if (build_require_space_after(s, prefix)) { + syntax_error(token_for_pos, "Expected a space after #+%.*s", LIT(prefix)); + return true; + } s = string_trim_whitespace(substring(s, prefix.len, s.len)); if (s.len == 0) { @@ -6367,6 +6386,10 @@ gb_internal String vet_tag_get_token(String s, String *out, bool allow_colon) { gb_internal u64 parse_vet_tag(Token token_for_pos, String s) { String const prefix = str_lit("vet"); GB_ASSERT(string_starts_with(s, prefix)); + if (build_require_space_after(s, prefix)) { + syntax_error(token_for_pos, "Expected a space after #+%.*s", LIT(prefix)); + return true; + } s = string_trim_whitespace(substring(s, prefix.len, s.len)); u64 vet_flags = build_context.vet_flags; @@ -6424,6 +6447,10 @@ gb_internal u64 parse_vet_tag(Token token_for_pos, String s) { gb_internal u64 parse_feature_tag(Token token_for_pos, String s) { String const prefix = str_lit("feature"); GB_ASSERT(string_starts_with(s, prefix)); + if (build_require_space_after(s, prefix)) { + syntax_error(token_for_pos, "Expected a space after #+%.*s", LIT(prefix)); + return true; + } s = string_trim_whitespace(substring(s, prefix.len, s.len)); if (s.len == 0) { -- cgit v1.2.3 From f6322b4b31fb0a5cc343d4bae31ebc09639e3403 Mon Sep 17 00:00:00 2001 From: Shane Shrybman Date: Wed, 28 Jan 2026 14:18:30 -0500 Subject: Fix for vet flags. All combinations of vet flags on the command line and top of file are working --- src/parser.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src/parser.cpp') diff --git a/src/parser.cpp b/src/parser.cpp index af533d9a3..1f08eaec1 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -6383,7 +6383,7 @@ gb_internal String vet_tag_get_token(String s, String *out, bool allow_colon) { } -gb_internal u64 parse_vet_tag(Token token_for_pos, String s) { +gb_internal u64 parse_vet_tag(Token token_for_pos, String s, u64 base_vet_flags) { String const prefix = str_lit("vet"); GB_ASSERT(string_starts_with(s, prefix)); if (build_require_space_after(s, prefix)) { @@ -6392,7 +6392,7 @@ gb_internal u64 parse_vet_tag(Token token_for_pos, String s) { } s = string_trim_whitespace(substring(s, prefix.len, s.len)); - u64 vet_flags = build_context.vet_flags; + u64 vet_flags = base_vet_flags; if (s.len == 0) { vet_flags |= VetFlag_All; @@ -6624,7 +6624,7 @@ gb_internal bool parse_file_tag(const String &lc, const Token &tok, AstFile *f) return false; } } else if (string_starts_with(lc, str_lit("vet"))) { - f->vet_flags = parse_vet_tag(tok, lc); + f->vet_flags = parse_vet_tag(tok, lc, ast_file_vet_flags(f)); f->vet_flags_set = true; } else if (string_starts_with(lc, str_lit("test"))) { if ((build_context.command_kind & Command_test) == 0) { -- cgit v1.2.3 From 07d814d9cf3bf2065e4122dba91817935dca7c60 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 29 Jan 2026 10:48:05 +0000 Subject: Add `struct #simple` to force a struct to use simple comparison if all of the fields "nearly simply comparable". --- base/runtime/core.odin | 1 + base/runtime/print.odin | 2 ++ core/odin/ast/ast.odin | 1 + core/odin/parser/parser.odin | 7 +++++++ core/reflect/types.odin | 5 +++-- src/check_expr.cpp | 6 ++++-- src/check_type.cpp | 15 +++++++++++++++ src/parser.cpp | 13 ++++++++++--- src/parser.hpp | 1 + src/types.cpp | 25 +++++++++++++++++++++++-- 10 files changed, 67 insertions(+), 9 deletions(-) (limited to 'src/parser.cpp') diff --git a/base/runtime/core.odin b/base/runtime/core.odin index 58a0b8ad1..5a0b3766c 100644 --- a/base/runtime/core.odin +++ b/base/runtime/core.odin @@ -122,6 +122,7 @@ Type_Info_Struct_Flag :: enum u8 { raw_union = 1, all_or_none = 2, align = 3, + simple = 4, } Type_Info_Struct :: struct { diff --git a/base/runtime/print.odin b/base/runtime/print.odin index 2deb0f4b1..2cdde8152 100644 --- a/base/runtime/print.odin +++ b/base/runtime/print.odin @@ -421,6 +421,7 @@ print_type :: #force_no_inline proc "contextless" (ti: ^Type_Info) { if .packed in info.flags { print_string("#packed ") } if .raw_union in info.flags { print_string("#raw_union ") } if .all_or_none in info.flags { print_string("#all_or_none ") } + if .simple in info.flags { print_string("#simple ") } if .align in info.flags { print_string("#align(") print_u64(u64(ti.align)) @@ -835,6 +836,7 @@ write_write_type :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, t if .packed in info.flags { write_string(i, buf, "#packed ") or_return } if .raw_union in info.flags { write_string(i, buf, "#raw_union ") or_return } if .all_or_none in info.flags { write_string(i, buf, "#all_or_none ") or_return } + if .simple in info.flags { write_string(i, buf, "#simple ") or_return } if .align in info.flags { write_string(i, buf, "#align(") or_return write_u64(i, buf, u64(ti.align)) or_return diff --git a/core/odin/ast/ast.odin b/core/odin/ast/ast.odin index 6755ca4d0..ec22db434 100644 --- a/core/odin/ast/ast.odin +++ b/core/odin/ast/ast.odin @@ -798,6 +798,7 @@ Struct_Type :: struct { is_raw_union: bool, is_no_copy: bool, is_all_or_none: bool, + is_simple: bool, fields: ^Field_List, name_count: int, } diff --git a/core/odin/parser/parser.odin b/core/odin/parser/parser.odin index 719cb0374..a18942e6b 100644 --- a/core/odin/parser/parser.odin +++ b/core/odin/parser/parser.odin @@ -2667,6 +2667,7 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr { is_raw_union: bool is_no_copy: bool is_all_or_none: bool + is_simple: bool fields: ^ast.Field_List name_count: int @@ -2695,6 +2696,11 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr { error(p, tag.pos, "duplicate struct tag '#%s'", tag.text) } is_all_or_none = true + case "simple": + if is_simple { + error(p, tag.pos, "duplicate struct tag '#%s'", tag.text) + } + is_simple = true case "align": if align != nil { error(p, tag.pos, "duplicate struct tag '#%s'", tag.text) @@ -2769,6 +2775,7 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr { st.is_raw_union = is_raw_union st.is_no_copy = is_no_copy st.is_all_or_none = is_all_or_none + st.is_simple = is_simple st.fields = fields st.name_count = name_count st.where_token = where_token diff --git a/core/reflect/types.odin b/core/reflect/types.odin index d6d7011d1..385edb19b 100644 --- a/core/reflect/types.odin +++ b/core/reflect/types.odin @@ -696,9 +696,10 @@ write_type_writer :: #force_no_inline proc(w: io.Writer, ti: ^Type_Info, n_writt } io.write_string(w, "struct ", &n) or_return - if .packed in info.flags { io.write_string(w, "#packed ", &n) or_return } - if .raw_union in info.flags { io.write_string(w, "#raw_union ", &n) or_return } + if .packed in info.flags { io.write_string(w, "#packed ", &n) or_return } + if .raw_union in info.flags { io.write_string(w, "#raw_union ", &n) or_return } if .all_or_none in info.flags { io.write_string(w, "#all_or_none ", &n) or_return } + if .simple in info.flags { io.write_string(w, "#simple ", &n) or_return } if .align in info.flags { io.write_string(w, "#align(", &n) or_return io.write_i64(w, i64(ti.align), 10, &n) or_return diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 46455aacf..36b4f6ec6 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -12692,8 +12692,10 @@ gb_internal gbString write_expr_to_string(gbString str, Ast *node, bool shorthan str = write_expr_to_string(str, st->polymorphic_params, shorthand); str = gb_string_appendc(str, ") "); } - if (st->is_packed) str = gb_string_appendc(str, "#packed "); - if (st->is_raw_union) str = gb_string_appendc(str, "#raw_union "); + if (st->is_packed) str = gb_string_appendc(str, "#packed "); + if (st->is_raw_union) str = gb_string_appendc(str, "#raw_union "); + if (st->is_all_or_none) str = gb_string_appendc(str, "#all_or_none "); + if (st->is_simple) str = gb_string_appendc(str, "#simple "); if (st->align) { str = gb_string_appendc(str, "#align "); str = write_expr_to_string(str, st->align, shorthand); diff --git a/src/check_type.cpp b/src/check_type.cpp index 4b8f7b6ac..41c5f48d1 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -679,6 +679,21 @@ gb_internal void check_struct_type(CheckerContext *ctx, Type *struct_type, Ast * gb_unused(where_clause_ok); } check_struct_fields(ctx, node, &struct_type->Struct.fields, &struct_type->Struct.tags, st->fields, min_field_count, struct_type, context); + + if (st->is_simple) { + bool success = true; + for (Entity *f : struct_type->Struct.fields) { + if (!is_type_nearly_simple_compare(f->type)) { + gbString s = type_to_string(f->type); + error(f->token, "'struct #simple' requires all fields to be at least 'nearly simple compare', got %s", s); + gb_string_free(s); + } + } + if (success) { + struct_type->Struct.is_simple = true; + } + } + wait_signal_set(&struct_type->Struct.fields_wait_signal); } diff --git a/src/parser.cpp b/src/parser.cpp index af533d9a3..2eb559e06 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -1230,7 +1230,7 @@ gb_internal Ast *ast_dynamic_array_type(AstFile *f, Token token, Ast *elem) { } gb_internal Ast *ast_struct_type(AstFile *f, Token token, Slice fields, isize field_count, - Ast *polymorphic_params, bool is_packed, bool is_raw_union, bool is_all_or_none, + Ast *polymorphic_params, bool is_packed, bool is_raw_union, bool is_all_or_none, bool is_simple, Ast *align, Ast *min_field_align, Ast *max_field_align, Token where_token, Array const &where_clauses) { Ast *result = alloc_ast_node(f, Ast_StructType); @@ -1241,6 +1241,7 @@ gb_internal Ast *ast_struct_type(AstFile *f, Token token, Slice fields, i result->StructType.is_packed = is_packed; result->StructType.is_raw_union = is_raw_union; result->StructType.is_all_or_none = is_all_or_none; + result->StructType.is_simple = is_simple; result->StructType.align = align; result->StructType.min_field_align = min_field_align; result->StructType.max_field_align = max_field_align; @@ -2788,6 +2789,7 @@ gb_internal Ast *parse_operand(AstFile *f, bool lhs) { bool is_packed = false; bool is_all_or_none = false; bool is_raw_union = false; + bool is_simple = false; Ast *align = nullptr; Ast *min_field_align = nullptr; Ast *max_field_align = nullptr; @@ -2869,11 +2871,16 @@ gb_internal Ast *parse_operand(AstFile *f, bool lhs) { error_line("\tSuggestion: #max_field_align(%s)", s); gb_string_free(s); } - }else if (tag.string == "raw_union") { + } else if (tag.string == "raw_union") { if (is_raw_union) { syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); } is_raw_union = true; + } else if (tag.string == "simple") { + if (is_simple) { + syntax_error(tag, "Duplicate struct tag '#%.*s'", LIT(tag.string)); + } + is_simple = true; } else { syntax_error(tag, "Invalid struct tag '#%.*s'", LIT(tag.string)); } @@ -2919,7 +2926,7 @@ gb_internal Ast *parse_operand(AstFile *f, bool lhs) { parser_check_polymorphic_record_parameters(f, polymorphic_params); return ast_struct_type(f, token, decls, name_count, - polymorphic_params, is_packed, is_raw_union, is_all_or_none, + polymorphic_params, is_packed, is_raw_union, is_all_or_none, is_simple, align, min_field_align, max_field_align, where_token, where_clauses); } break; diff --git a/src/parser.hpp b/src/parser.hpp index 011330438..39f56ffae 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -780,6 +780,7 @@ AST_KIND(_TypeBegin, "", bool) \ bool is_raw_union; \ bool is_no_copy; \ bool is_all_or_none; \ + bool is_simple; \ }) \ AST_KIND(UnionType, "union type", struct { \ Scope *scope; \ diff --git a/src/types.cpp b/src/types.cpp index 03ff95033..a7f2bfda2 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -163,6 +163,7 @@ struct TypeStruct { bool is_packed : 1; bool is_raw_union : 1; bool is_all_or_none : 1; + bool is_simple : 1; bool is_poly_specialized : 1; std::atomic are_offsets_being_processed; @@ -2708,6 +2709,9 @@ gb_internal bool is_type_simple_compare(Type *t) { return is_type_simple_compare(t->Matrix.elem); case Type_Struct: + if (t->Struct.is_simple) { + return true; + } for_array(i, t->Struct.fields) { Entity *f = t->Struct.fields[i]; if (!is_type_simple_compare(f->type)) { @@ -2768,12 +2772,16 @@ gb_internal bool is_type_nearly_simple_compare(Type *t) { case Type_SoaPointer: case Type_Proc: case Type_BitSet: + case Type_BitField: return true; case Type_Matrix: return is_type_nearly_simple_compare(t->Matrix.elem); case Type_Struct: + if (t->Struct.is_simple) { + return true; + } for_array(i, t->Struct.fields) { Entity *f = t->Struct.fields[i]; if (!is_type_nearly_simple_compare(f->type)) { @@ -2795,6 +2803,17 @@ gb_internal bool is_type_nearly_simple_compare(Type *t) { case Type_SimdVector: return is_type_nearly_simple_compare(t->SimdVector.elem); + case Type_Tuple: + if (t->Tuple.variables.count == 1) { + return is_type_nearly_simple_compare(t->Tuple.variables[0]->type); + } + break; + + case Type_Slice: + case Type_DynamicArray: + case Type_Map: + return false; + } return false; @@ -5110,9 +5129,11 @@ gb_internal gbString write_type_to_string(gbString str, Type *type, bool shortha str = gb_string_appendc(str, ")"); } - if (type->Struct.is_packed) str = gb_string_appendc(str, " #packed"); - if (type->Struct.is_raw_union) str = gb_string_appendc(str, " #raw_union"); + if (type->Struct.is_packed) str = gb_string_appendc(str, " #packed"); + if (type->Struct.is_raw_union) str = gb_string_appendc(str, " #raw_union"); if (type->Struct.custom_align != 0) str = gb_string_append_fmt(str, " #align %d", cast(int)type->Struct.custom_align); + if (type->Struct.is_all_or_none) str = gb_string_appendc(str, " #all_or_none"); + if (type->Struct.is_simple) str = gb_string_appendc(str, " #simple"); str = gb_string_appendc(str, " {"); -- cgit v1.2.3