diff --git a/core/_preload.odin b/core/_preload.odin index 995b1d72a..35d9a4a1c 100644 --- a/core/_preload.odin +++ b/core/_preload.odin @@ -13,67 +13,67 @@ // IMPORTANT NOTE(bill): Do not change the order of any of this data // The compiler relies upon this _exact_ order type Type_Info_Member struct #ordered { - name: string; // can be empty if tuple - type_info: ^Type_Info; - offset: int; // offsets are not used in tuples -}; + name string; // can be empty if tuple + type_info ^Type_Info; + offset int; // offsets are not used in tuples +} type Type_Info_Record struct #ordered { - fields: []Type_Info_Member; - size: int; // in bytes - align: int; // in bytes - packed: bool; - ordered: bool; -}; + fields []Type_Info_Member; + size int; // in bytes + align int; // in bytes + packed bool; + ordered bool; +} type Type_Info union { - Named: struct #ordered { - name: string; - base: ^Type_Info; // This will _not_ be a Type_Info.Named + Named struct #ordered { + name string; + base ^Type_Info; // This will _not_ be a Type_Info.Named }; - Integer: struct #ordered { - size: int; // in bytes - signed: bool; + Integer struct #ordered { + size int; // in bytes + signed bool; }; - Float: struct #ordered { - size: int; // in bytes + Float struct #ordered { + size int; // in bytes }; - Any: struct #ordered {}; - String: struct #ordered {}; - Boolean: struct #ordered {}; - Pointer: struct #ordered { - elem: ^Type_Info; // nil -> rawptr + Any struct #ordered {}; + String struct #ordered {}; + Boolean struct #ordered {}; + Pointer struct #ordered { + elem ^Type_Info; // nil -> rawptr }; - Maybe: struct #ordered { - elem: ^Type_Info; + Maybe struct #ordered { + elem ^Type_Info; }; - Procedure: struct #ordered { - params: ^Type_Info; // Type_Info.Tuple - results: ^Type_Info; // Type_Info.Tuple - variadic: bool; + Procedure struct #ordered { + params ^Type_Info; // Type_Info.Tuple + results ^Type_Info; // Type_Info.Tuple + variadic bool; }; - Array: struct #ordered { - elem: ^Type_Info; - elem_size: int; - count: int; + Array struct #ordered { + elem ^Type_Info; + elem_size int; + count int; }; - Slice: struct #ordered { - elem: ^Type_Info; - elem_size: int; + Slice struct #ordered { + elem ^Type_Info; + elem_size int; }; - Vector: struct #ordered { - elem: ^Type_Info; - elem_size: int; - count: int; - align: int; + Vector struct #ordered { + elem ^Type_Info; + elem_size int; + count int; + align int; }; - Tuple: Type_Info_Record; - Struct: Type_Info_Record; - Union: Type_Info_Record; - Raw_Union: Type_Info_Record; - Enum: struct #ordered { - base: ^Type_Info; - values: []i64; - names: []string; + Tuple Type_Info_Record; + Struct Type_Info_Record; + Union Type_Info_Record; + Raw_Union Type_Info_Record; + Enum struct #ordered { + base ^Type_Info; + values []i64; + names []string; }; }; @@ -126,18 +126,18 @@ type Allocator_Proc proc(allocator_data rawptr, mode Allocator_Mode, type Allocator struct #ordered { - procedure: Allocator_Proc; - data: rawptr; + procedure Allocator_Proc; + data rawptr; } type Context struct #ordered { - thread_id: int; + thread_id int; - allocator: Allocator; + allocator Allocator; - user_data: rawptr; - user_index: int; + user_data rawptr; + user_index int; } #thread_local var __context Context; diff --git a/core/mem.odin b/core/mem.odin index ecd626750..9c37018ce 100644 --- a/core/mem.odin +++ b/core/mem.odin @@ -90,7 +90,7 @@ proc align_forward(ptr rawptr, align int) -> rawptr { type Allocation_Header struct { - size: int; + size int; } proc allocation_header_fill(header ^Allocation_Header, data rawptr, size int) { header.size = size; @@ -115,14 +115,14 @@ proc allocation_header(data rawptr) -> ^Allocation_Header { // Custom allocators type Arena struct { - backing: Allocator; - memory: []byte; - temp_count: int; + backing Allocator; + memory []byte; + temp_count int; } type Arena_Temp_Memory struct { - arena: ^Arena; - original_count: int; + arena ^Arena; + original_count int; } diff --git a/core/os_windows.odin b/core/os_windows.odin index dbf20ed5d..553b8bd49 100644 --- a/core/os_windows.odin +++ b/core/os_windows.odin @@ -4,13 +4,13 @@ type File_Time u64; type File_Handle raw_union { - p: rawptr; - i: int; + p rawptr; + i int; } type File struct { - handle: File_Handle; - last_write_time: File_Time; + handle File_Handle; + last_write_time File_Time; } proc open(name string) -> (File, bool) { diff --git a/core/sync.odin b/core/sync.odin index 9bcede9a1..9b317e56d 100644 --- a/core/sync.odin +++ b/core/sync.odin @@ -2,14 +2,14 @@ #import "atomic.odin"; type Semaphore struct { - handle: win32.HANDLE; + handle win32.HANDLE; } type Mutex struct { - semaphore: Semaphore; - counter: i32; - owner: i32; - recursion: i32; + semaphore Semaphore; + counter i32; + owner i32; + recursion i32; } diff --git a/core/sys/windows.odin b/core/sys/windows.odin index 782494cbb..5ddbb5cab 100644 --- a/core/sys/windows.odin +++ b/core/sys/windows.odin @@ -51,62 +51,62 @@ const SM_CYSCREEN = 1; const SW_SHOW = 5; type POINT struct #ordered { - x, y: i32; + x, y i32; } type WNDCLASSEXA struct #ordered { - size, style: u32; - wnd_proc: WNDPROC; - cls_extra, wnd_extra: i32; - instance: HINSTANCE; - icon: HICON; - cursor: HCURSOR; - background: HBRUSH; - menu_name, class_name: ^u8; - sm: HICON; + size, style u32; + wnd_proc WNDPROC; + cls_extra, wnd_extra i32; + instance HINSTANCE; + icon HICON; + cursor HCURSOR; + background HBRUSH; + menu_name, class_name ^u8; + sm HICON; } type MSG struct #ordered { - hwnd: HWND; - message: u32; - wparam: WPARAM; - lparam: LPARAM; - time: u32; - pt: POINT; + hwnd HWND; + message u32; + wparam WPARAM; + lparam LPARAM; + time u32; + pt POINT; } type RECT struct #ordered { - left: i32; - top: i32; - right: i32; - bottom: i32; + left i32; + top i32; + right i32; + bottom i32; } type FILETIME struct #ordered { - low_date_time, high_date_time: u32; + low_date_time, high_date_time u32; } type BY_HANDLE_FILE_INFORMATION struct #ordered { - file_attributes: u32; + file_attributes u32; creation_time, last_access_time, - last_write_time: FILETIME; + last_write_time FILETIME; volume_serial_number, file_size_high, file_size_low, number_of_links, file_index_high, - file_index_low: u32; + file_index_low u32; } type WIN32_FILE_ATTRIBUTE_DATA struct #ordered { - file_attributes: u32; + file_attributes u32; creation_time, last_access_time, - last_write_time: FILETIME; + last_write_time FILETIME; file_size_high, - file_size_low: u32; + file_size_low u32; } type GET_FILEEX_INFO_LEVELS i32; @@ -209,9 +209,9 @@ const HEAP_ZERO_MEMORY = 0x00000008; // Synchronization type SECURITY_ATTRIBUTES struct #ordered { - length: u32; - security_descriptor: rawptr; - inherit_handle: BOOL; + length u32; + security_descriptor rawptr; + inherit_handle BOOL; } const INFINITE = 0xffffffff; @@ -242,24 +242,24 @@ proc ReadBarrier () #foreign // GDI type BITMAPINFOHEADER struct #ordered { - size: u32; - width, height: i32; - planes, bit_count: i16; - compression: u32; - size_image: u32; - x_pels_per_meter: i32; - y_pels_per_meter: i32; - clr_used: u32; - clr_important: u32; + size u32; + width, height i32; + planes, bit_count i16; + compression u32; + size_image u32; + x_pels_per_meter i32; + y_pels_per_meter i32; + clr_used u32; + clr_important u32; } type BITMAPINFO struct #ordered { - using header: BITMAPINFOHEADER; - colors: [1]RGBQUAD; + using header BITMAPINFOHEADER; + colors [1]RGBQUAD; } type RGBQUAD struct #ordered { - blue, green, red, reserved: byte; + blue, green, red, reserved byte; } const BI_RGB = 0; @@ -315,7 +315,7 @@ type wglCreateContextAttribsARBType proc(hdc HDC, hshareContext rawptr, attribLi type PIXELFORMATDESCRIPTOR struct #ordered { size, version, - flags: u32; + flags u32; pixel_type, color_bits, @@ -336,11 +336,11 @@ type PIXELFORMATDESCRIPTOR struct #ordered { stencil_bits, aux_buffers, layer_type, - reserved: byte; + reserved byte; layer_mask, visible_mask, - damage_mask: u32; + damage_mask u32; } proc GetDC (h HANDLE) -> HDC #foreign diff --git a/core/utf8.odin b/core/utf8.odin index 4a9a5bb84..73688fd75 100644 --- a/core/utf8.odin +++ b/core/utf8.odin @@ -11,7 +11,7 @@ const SURROGATE_MAX = 0xdfff; type Accept_Range struct { - lo, hi: u8; + lo, hi u8; }; accept_ranges := [5]Accept_Range{ diff --git a/src/checker/expr.c b/src/checker/expr.c index 47964ec5a..8900cb4a7 100644 --- a/src/checker/expr.c +++ b/src/checker/expr.c @@ -464,37 +464,29 @@ void populate_using_entity_map(Checker *c, AstNode *node, Type *t, MapEntity *en void check_fields(Checker *c, AstNode *node, AstNodeArray decls, Entity **fields, isize field_count, - Entity **other_fields, isize other_field_count, String context) { gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); MapEntity entity_map = {0}; - map_entity_init_with_reserve(&entity_map, c->tmp_allocator, 2*(field_count+other_field_count)); + map_entity_init_with_reserve(&entity_map, c->tmp_allocator, 2*field_count); isize other_field_index = 0; Entity *using_index_expr = NULL; - DelayedOtherFields dof = {0}; - dof.other_fields = other_fields; - dof.other_field_count = other_field_count; - dof.entity_map = &entity_map; - - check_scope_decls(c, decls, 1.2*other_field_count, &dof); - if (node->kind == AstNode_UnionType) { isize field_index = 0; fields[field_index++] = make_entity_type_name(c->allocator, c->context.scope, empty_token, NULL); for_array(decl_index, decls) { AstNode *decl = decls.e[decl_index]; - if (decl->kind != AstNode_VarDecl) { + if (decl->kind != AstNode_Parameter) { continue; } - ast_node(vd, VarDecl, decl); - Type *base_type = check_type_extra(c, vd->type, NULL); + ast_node(p, Parameter, decl); + Type *base_type = check_type_extra(c, p->type, NULL); - for_array(name_index, vd->names) { - AstNode *name = vd->names.e[name_index]; + for_array(name_index, p->names) { + AstNode *name = p->names.e[name_index]; if (!ast_node_expect(name, AstNode_Ident)) { continue; } @@ -526,28 +518,28 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls, isize field_index = 0; for_array(decl_index, decls) { AstNode *decl = decls.e[decl_index]; - if (decl->kind != AstNode_VarDecl) { + if (decl->kind != AstNode_Parameter) { continue; } - ast_node(vd, VarDecl, decl); + ast_node(param, Parameter, decl); - Type *type = check_type_extra(c, vd->type, NULL); + Type *type = check_type_extra(c, param->type, NULL); - if (vd->is_using) { - if (vd->names.count > 1) { - error_node(vd->names.e[0], "Cannot apply `using` to more than one of the same type"); + if (param->is_using) { + if (param->names.count > 1) { + error_node(param->names.e[0], "Cannot apply `using` to more than one of the same type"); } } - for_array(name_index, vd->names) { - AstNode *name = vd->names.e[name_index]; + for_array(name_index, param->names) { + AstNode *name = param->names.e[name_index]; if (!ast_node_expect(name, AstNode_Ident)) { continue; } Token name_token = name->Ident; - Entity *e = make_entity_field(c->allocator, c->context.scope, name_token, type, vd->is_using, cast(i32)field_index); + Entity *e = make_entity_field(c->allocator, c->context.scope, name_token, type, param->is_using, cast(i32)field_index); e->identifier = name; if (str_eq(name_token.string, str_lit("_"))) { fields[field_index++] = e; @@ -566,19 +558,19 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls, } - if (vd->is_using) { + if (param->is_using) { Type *t = base_type(type_deref(type)); if (!is_type_struct(t) && !is_type_raw_union(t) && - vd->names.count >= 1 && - vd->names.e[0]->kind == AstNode_Ident) { - Token name_token = vd->names.e[0]->Ident; + param->names.count >= 1 && + param->names.e[0]->kind == AstNode_Ident) { + Token name_token = param->names.e[0]->Ident; if (is_type_indexable(t)) { bool ok = true; for_array(emi, entity_map.entries) { Entity *e = entity_map.entries.e[emi].value; if (e->kind == Entity_Variable && e->flags & EntityFlag_Anonymous) { if (is_type_indexable(e->type)) { - if (e->identifier != vd->names.e[0]) { + if (e->identifier != param->names.e[0]) { ok = false; using_index_expr = e; break; @@ -643,36 +635,24 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) { ast_node(st, StructType, node); isize field_count = 0; - isize other_field_count = 0; for_array(field_index, st->fields) { AstNode *field = st->fields.e[field_index]; switch (field->kind) { - case_ast_node(vd, VarDecl, field); - field_count += vd->names.count; - case_end; - - case_ast_node(cd, ConstDecl, field); - other_field_count += cd->names.count; - case_end; - - case_ast_node(td, TypeDecl, field); - other_field_count += 1; + case_ast_node(p, Parameter, field); + field_count += p->names.count; case_end; } } Entity **fields = gb_alloc_array(c->allocator, Entity *, field_count); - Entity **other_fields = gb_alloc_array(c->allocator, Entity *, other_field_count); - check_fields(c, node, st->fields, fields, field_count, other_fields, other_field_count, str_lit("struct")); + check_fields(c, node, st->fields, fields, field_count, str_lit("struct")); struct_type->Record.struct_is_packed = st->is_packed; struct_type->Record.struct_is_ordered = st->is_ordered; struct_type->Record.fields = fields; struct_type->Record.fields_in_src_order = fields; struct_type->Record.field_count = field_count; - struct_type->Record.other_fields = other_fields; - struct_type->Record.other_field_count = other_field_count; if (!st->is_packed && !st->is_ordered) { // NOTE(bill): Reorder fields for reduced size/performance @@ -704,33 +684,21 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) { ast_node(ut, UnionType, node); isize field_count = 1; - isize other_field_count = 0; for_array(field_index, ut->fields) { AstNode *field = ut->fields.e[field_index]; switch (field->kind) { - case_ast_node(vd, VarDecl, field); - field_count += vd->names.count; - case_end; - - case_ast_node(cd, ConstDecl, field); - other_field_count += cd->names.count; - case_end; - - case_ast_node(td, TypeDecl, field); - other_field_count += 1; + case_ast_node(p, Parameter, field); + field_count += p->names.count; case_end; } } Entity **fields = gb_alloc_array(c->allocator, Entity *, field_count); - Entity **other_fields = gb_alloc_array(c->allocator, Entity *, other_field_count); - check_fields(c, node, ut->fields, fields, field_count, other_fields, other_field_count, str_lit("union")); + check_fields(c, node, ut->fields, fields, field_count, str_lit("union")); union_type->Record.fields = fields; union_type->Record.field_count = field_count; - union_type->Record.other_fields = other_fields; - union_type->Record.other_field_count = other_field_count; } void check_raw_union_type(Checker *c, Type *union_type, AstNode *node) { @@ -739,33 +707,21 @@ void check_raw_union_type(Checker *c, Type *union_type, AstNode *node) { ast_node(ut, RawUnionType, node); isize field_count = 0; - isize other_field_count = 0; for_array(field_index, ut->fields) { AstNode *field = ut->fields.e[field_index]; switch (field->kind) { - case_ast_node(vd, VarDecl, field); - field_count += vd->names.count; - case_end; - - case_ast_node(cd, ConstDecl, field); - other_field_count += cd->names.count; - case_end; - - case_ast_node(td, TypeDecl, field); - other_field_count += 1; + case_ast_node(p, Parameter, field); + field_count += p->names.count; case_end; } } Entity **fields = gb_alloc_array(c->allocator, Entity *, field_count); - Entity **other_fields = gb_alloc_array(c->allocator, Entity *, other_field_count); - check_fields(c, node, ut->fields, fields, field_count, other_fields, other_field_count, str_lit("raw union")); + check_fields(c, node, ut->fields, fields, field_count, str_lit("raw_union")); union_type->Record.fields = fields; union_type->Record.field_count = field_count; - union_type->Record.other_fields = other_fields; - union_type->Record.other_field_count = other_field_count; } GB_COMPARE_PROC(cmp_enum_order) { @@ -895,11 +851,11 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod gb_sort_array(fields, field_index, cmp_enum_order); - enum_type->Record.other_fields = fields; - enum_type->Record.other_field_count = field_index; + enum_type->Record.enum_values = fields; + enum_type->Record.enum_value_count = field_index; enum_type->Record.enum_count = make_entity_constant(c->allocator, NULL, - make_token_ident(str_lit("count")), t_int, make_exact_value_integer(enum_type->Record.other_field_count)); + make_token_ident(str_lit("count")), t_int, make_exact_value_integer(enum_type->Record.enum_value_count)); enum_type->Record.min_value = make_entity_constant(c->allocator, NULL, make_token_ident(str_lit("min_value")), constant_type, make_exact_value_integer(min_value)); enum_type->Record.max_value = make_entity_constant(c->allocator, NULL, @@ -3599,8 +3555,8 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id ExactValue value = make_exact_value_string(str_lit("")); if (operand->value.kind == ExactValue_Integer) { i64 index = operand->value.value_integer; - for (isize i = 0; i < type->Record.other_field_count; i++) { - Entity *f = type->Record.other_fields[i]; + for (isize i = 0; i < type->Record.enum_value_count; i++) { + Entity *f = type->Record.enum_values[i]; if (f->kind == Entity_Constant && f->Constant.value.kind == ExactValue_Integer) { i64 fv = f->Constant.value.value_integer; if (index == fv) { diff --git a/src/checker/stmt.c b/src/checker/stmt.c index 9e3efc204..f1074e2e6 100644 --- a/src/checker/stmt.c +++ b/src/checker/stmt.c @@ -907,9 +907,9 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { switch (e->kind) { case Entity_TypeName: { Type *t = base_type(e->type); - if (is_type_struct(t) || is_type_enum(t)) { - for (isize i = 0; i < t->Record.other_field_count; i++) { - Entity *f = t->Record.other_fields[i]; + if (is_type_enum(t)) { + for (isize i = 0; i < t->Record.enum_value_count; i++) { + Entity *f = t->Record.enum_values[i]; Entity *found = scope_insert_entity(c->context.scope, f); if (found != NULL) { gbString expr_str = expr_to_string(expr); @@ -931,17 +931,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } f->using_parent = e; } - for (isize i = 0; i < t->Record.other_field_count; i++) { - Entity *f = t->Record.other_fields[i]; - Entity *found = scope_insert_entity(c->context.scope, f); - if (found != NULL) { - gbString expr_str = expr_to_string(expr); - error(us->token, "Namespace collision while `using` `%s` of: %.*s", expr_str, LIT(found->token.string)); - gb_string_free(expr_str); - return; - } - f->using_parent = e; - } } } break; diff --git a/src/checker/types.c b/src/checker/types.c index 45b40b8e0..a09254061 100644 --- a/src/checker/types.c +++ b/src/checker/types.c @@ -84,6 +84,8 @@ typedef struct TypeRecord { Entity * enum_count; Entity * min_value; Entity * max_value; + Entity **enum_values; + i32 enum_value_count; }; struct { // struct only i64 * struct_offsets; @@ -93,10 +95,6 @@ typedef struct TypeRecord { Entity **fields_in_src_order; // Entity_Variable }; }; - - // Entity_Constant or Entity_TypeName - Entity **other_fields; - i32 other_field_count; } TypeRecord; #define TYPE_KINDS \ @@ -984,19 +982,19 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n } } - for (isize i = 0; i < type->Record.other_field_count; i++) { - Entity *f = type->Record.other_fields[i]; - GB_ASSERT(f->kind != Entity_Variable); - String str = f->token.string; - - if (str_eq(field_name, str)) { - sel.entity = f; - selection_add_index(&sel, i); - return sel; - } - } - if (is_type_enum(type)) { + for (isize i = 0; i < type->Record.enum_value_count; i++) { + Entity *f = type->Record.enum_values[i]; + GB_ASSERT(f->kind != Entity_Variable); + String str = f->token.string; + + if (str_eq(field_name, str)) { + sel.entity = f; + selection_add_index(&sel, i); + return sel; + } + } + if (str_eq(field_name, str_lit("count"))) { sel.entity = type->Record.enum_count; return sel; diff --git a/src/parser.c b/src/parser.c index cd8a8bd27..e5c64ae88 100644 --- a/src/parser.c +++ b/src/parser.c @@ -1646,8 +1646,9 @@ AstNode *parse_atom_expr(AstFile *f, bool lhs) { f->expr_level++; open = expect_token(f, Token_OpenBracket); - if (f->curr_token.kind != Token_Colon) + if (f->curr_token.kind != Token_Colon) { indices[0] = parse_expr(f, false); + } isize colon_count = 0; Token colons[2] = {0}; @@ -2062,8 +2063,9 @@ AstNode *parse_proc_type(AstFile *f) { } -AstNodeArray parse_parameter_list(AstFile *f, bool allow_using, TokenKind follow) { +AstNodeArray parse_parameter_list(AstFile *f, isize *name_count_, bool allow_using, TokenKind separator, TokenKind follow) { AstNodeArray params = make_ast_node_array(f); + isize name_count = 0; while (f->curr_token.kind != follow && f->curr_token.kind != Token_EOF) { @@ -2088,6 +2090,8 @@ AstNodeArray parse_parameter_list(AstFile *f, bool allow_using, TokenKind follow is_using = false; } + name_count += names.count; + // expect_token_after(f, Token_Colon, "parameter list"); AstNode *type = NULL; @@ -2114,77 +2118,27 @@ AstNodeArray parse_parameter_list(AstFile *f, bool allow_using, TokenKind follow syntax_error(f->curr_token, "Expected a type for this parameter declaration"); } - array_add(¶ms, make_parameter(f, names, type, is_using)); - if (!allow_token(f, Token_Comma)) { - break; + AstNode *param = make_parameter(f, names, type, is_using); + array_add(¶ms, param); + + + if (separator == Token_Semicolon) { + expect_semicolon(f, param); + } else { + if (!allow_token(f, separator)) { + break; + } } } + if (name_count_) *name_count_ = name_count; + return params; } -AstNodeArray parse_record_params(AstFile *f, isize *decl_count_, bool allow_using, String context) { - AstNodeArray decls = make_ast_node_array(f); - isize decl_count = 0; - - while (f->curr_token.kind != Token_CloseBrace && - f->curr_token.kind != Token_EOF) { - AstNode *decl = parse_stmt(f); - if (is_ast_node_decl(decl) || - decl->kind == AstNode_UsingStmt || - decl->kind == AstNode_EmptyStmt) { - switch (decl->kind) { - case AstNode_EmptyStmt: - break; - - case AstNode_ProcDecl: - syntax_error(f->curr_token, "Procedure declarations are not allowed within a %.*s", LIT(context)); - break; - - case AstNode_UsingStmt: { - bool is_using = true; - if (!allow_using) { - syntax_error(f->curr_token, "Cannot apply `using` to members of a %.*s", LIT(context)); - is_using = false; - } - if (decl->UsingStmt.node->kind == AstNode_VarDecl) { - AstNode *vd = decl->UsingStmt.node; - vd->VarDecl.is_using = is_using && allow_using; - if (vd->VarDecl.values.count > 0) { - syntax_error(f->curr_token, "Default variable assignments within a %.*s will be ignored", LIT(context)); - } - array_add(&decls, vd); - } else { - syntax_error_node(decl, "Illegal %.*s field", LIT(context)); - } - } break; - - case AstNode_VarDecl: { - if (decl->VarDecl.values.count > 0) { - syntax_error(f->curr_token, "Default variable assignments within a %.*s will be ignored", LIT(context)); - } - array_add(&decls, decl); - } - - case AstNode_BadDecl: - break; - - case AstNode_ConstDecl: - case AstNode_TypeDecl: - default: - decl_count += 1; - array_add(&decls, decl); - break; - } - } else { - syntax_error_node(decl, "Illegal record field: %.*s", LIT(ast_node_strings[decl->kind])); - } - } - - if (decl_count_) *decl_count_ = decl_count; - - return decls; +AstNodeArray parse_record_params(AstFile *f, isize *field_count_, bool allow_using, String context) { + return parse_parameter_list(f, field_count_, allow_using, Token_Semicolon, Token_CloseBrace); } AstNode *parse_identifier_or_type(AstFile *f) { @@ -2380,7 +2334,7 @@ void parse_proc_signature(AstFile *f, AstNodeArray *params, AstNodeArray *results) { expect_token(f, Token_OpenParen); - *params = parse_parameter_list(f, true, Token_CloseParen); + *params = parse_parameter_list(f, NULL, true, Token_Comma, Token_CloseParen); expect_token_after(f, Token_CloseParen, "parameter list"); *results = parse_results(f); } diff --git a/src/ssa.c b/src/ssa.c index c86df0969..f4100e9cf 100644 --- a/src/ssa.c +++ b/src/ssa.c @@ -2522,15 +2522,8 @@ void ssa_gen_global_type_name(ssaModule *m, Entity *e, String name) { ssa_module_add_value(m, e, t); map_ssa_value_set(&m->members, hash_string(name), t); - Type *bt = base_type(e->type); - if (bt->kind == Type_Record) { - TypeRecord *s = &bt->Record; - for (isize j = 0; j < s->other_field_count; j++) { - ssa_mangle_sub_type_name(m, s->other_fields[j], name); - } - } - - if (is_type_union(bt)) { + if (is_type_union(e->type)) { + Type *bt = base_type(e->type); TypeRecord *s = &bt->Record; // NOTE(bill): Zeroth entry is null (for `match type` stmts) for (isize j = 1; j < s->field_count; j++) { @@ -5418,13 +5411,12 @@ void ssa_gen_tree(ssaGen *s) { ssaValue *base = ssa_emit_struct_ep(proc, tag, 0); ssa_emit_store(proc, base, ssa_get_type_info_ptr(proc, type_info_data, enum_base)); - if (t->Record.other_field_count > 0) { - Entity **fields = t->Record.other_fields; - isize count = t->Record.other_field_count; + if (t->Record.enum_value_count > 0) { + Entity **fields = t->Record.enum_values; + isize count = t->Record.enum_value_count; ssaValue *value_array = NULL; ssaValue *name_array = NULL; - { Token token = {Token_Ident}; i32 id = cast(i32)entry_index;