authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2023-01-10 21:54:58+02:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2023-01-11 21:11:21+02:00
logd8128c272a087bbfc0b33a786c18267f49cd4982
tree2db7e2c6b4bb59ea23826703e2926b89cf630efc
parent1658e4893d749c7d1ed378cd34b6cbe1a132c0e9

Sema: fix typeInfo decls with usingnamespace

Closes #12403

3 files changed, 98 insertions(+), 34 deletions(-)

src/Module.zig+22-9
......@@ -528,10 +528,10 @@ pub const Decl = struct {
528528 /// Decl is marked alive, then it sends the Decl to the linker. Otherwise it
529529 /// deletes the Decl on the spot.
530530 alive: bool,
531 /// Whether the Decl is a `usingnamespace` declaration.
532 is_usingnamespace: bool,
533531 /// If true `name` is already fully qualified.
534532 name_fully_qualified: bool = false,
533 /// What kind of a declaration is this.
534 kind: Kind,
535535
536536 /// Represents the position of the code in the output file.
537537 /// This is populated regardless of semantic analysis and code generation.
......@@ -551,6 +551,14 @@ pub const Decl = struct {
551551 /// typed_value may need to be regenerated.
552552 dependencies: DepsTable = .{},
553553
554 pub const Kind = enum {
555 @"usingnamespace",
556 @"test",
557 @"comptime",
558 named,
559 anon,
560 };
561
554562 pub const Index = enum(u32) {
555563 _,
556564
......@@ -4438,7 +4446,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !bool {
44384446 // not the struct itself.
44394447 try sema.resolveTypeLayout(decl_tv.ty);
44404448
4441 if (decl.is_usingnamespace) {
4449 if (decl.kind == .@"usingnamespace") {
44424450 if (!decl_tv.ty.eql(Type.type, mod)) {
44434451 return sema.fail(&block_scope, ty_src, "expected type, found {}", .{
44444452 decl_tv.ty.fmt(mod),
......@@ -4964,26 +4972,31 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err
49644972
49654973 // Every Decl needs a name.
49664974 var is_named_test = false;
4975 var kind: Decl.Kind = .named;
49674976 const decl_name: [:0]const u8 = switch (decl_name_index) {
49684977 0 => name: {
49694978 if (export_bit) {
49704979 const i = iter.usingnamespace_index;
49714980 iter.usingnamespace_index += 1;
4981 kind = .@"usingnamespace";
49724982 break :name try std.fmt.allocPrintZ(gpa, "usingnamespace_{d}", .{i});
49734983 } else {
49744984 const i = iter.comptime_index;
49754985 iter.comptime_index += 1;
4986 kind = .@"comptime";
49764987 break :name try std.fmt.allocPrintZ(gpa, "comptime_{d}", .{i});
49774988 }
49784989 },
49794990 1 => name: {
49804991 const i = iter.unnamed_test_index;
49814992 iter.unnamed_test_index += 1;
4993 kind = .@"test";
49824994 break :name try std.fmt.allocPrintZ(gpa, "test_{d}", .{i});
49834995 },
49844996 2 => name: {
49854997 is_named_test = true;
49864998 const test_name = zir.nullTerminatedString(decl_doccomment_index);
4999 kind = .@"test";
49875000 break :name try std.fmt.allocPrintZ(gpa, "decltest.{s}", .{test_name});
49885001 },
49895002 else => name: {
......@@ -4991,6 +5004,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err
49915004 if (raw_name.len == 0) {
49925005 is_named_test = true;
49935006 const test_name = zir.nullTerminatedString(decl_name_index + 1);
5007 kind = .@"test";
49945008 break :name try std.fmt.allocPrintZ(gpa, "test.{s}", .{test_name});
49955009 } else {
49965010 break :name try gpa.dupeZ(u8, raw_name);
......@@ -4998,8 +5012,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err
49985012 },
49995013 };
50005014 const is_exported = export_bit and decl_name_index != 0;
5001 const is_usingnamespace = export_bit and decl_name_index == 0;
5002 if (is_usingnamespace) try namespace.usingnamespace_set.ensureUnusedCapacity(gpa, 1);
5015 if (kind == .@"usingnamespace") try namespace.usingnamespace_set.ensureUnusedCapacity(gpa, 1);
50035016
50045017 // We create a Decl for it regardless of analysis status.
50055018 const gop = try namespace.decls.getOrPutContextAdapted(
......@@ -5012,8 +5025,9 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err
50125025 if (!gop.found_existing) {
50135026 const new_decl_index = try mod.allocateNewDecl(namespace, decl_node, iter.parent_decl.src_scope);
50145027 const new_decl = mod.declPtr(new_decl_index);
5028 new_decl.kind = kind;
50155029 new_decl.name = decl_name;
5016 if (is_usingnamespace) {
5030 if (kind == .@"usingnamespace") {
50175031 namespace.usingnamespace_set.putAssumeCapacity(new_decl_index, is_pub);
50185032 }
50195033 log.debug("scan new {*} ({s}) into {*}", .{ new_decl, decl_name, namespace });
......@@ -5058,7 +5072,6 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err
50585072 }
50595073 new_decl.is_pub = is_pub;
50605074 new_decl.is_exported = is_exported;
5061 new_decl.is_usingnamespace = is_usingnamespace;
50625075 new_decl.has_align = has_align;
50635076 new_decl.has_linksection_or_addrspace = has_linksection_or_addrspace;
50645077 new_decl.zir_decl_index = @intCast(u32, decl_sub_index);
......@@ -5076,7 +5089,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) Allocator.Err
50765089
50775090 decl.is_pub = is_pub;
50785091 decl.is_exported = is_exported;
5079 decl.is_usingnamespace = is_usingnamespace;
5092 decl.kind = kind;
50805093 decl.has_align = has_align;
50815094 decl.has_linksection_or_addrspace = has_linksection_or_addrspace;
50825095 decl.zir_decl_index = @intCast(u32, decl_sub_index);
......@@ -5635,7 +5648,7 @@ pub fn allocateNewDecl(
56355648 .has_linksection_or_addrspace = false,
56365649 .has_align = false,
56375650 .alive = false,
5638 .is_usingnamespace = false,
5651 .kind = .anon,
56395652 };
56405653
56415654 return decl_and_index.decl_index;
src/Sema.zig+52-25
......@@ -16217,11 +16217,54 @@ fn typeInfoDecls(
1621716217 };
1621816218 try sema.queueFullTypeResolution(try declaration_ty.copy(sema.arena));
1621916219
16220 const decls_len = if (opt_namespace) |ns| ns.decls.count() else 0;
16221 const decls_vals = try decls_anon_decl.arena().alloc(Value, decls_len);
16222 for (decls_vals) |*decls_val, i| {
16223 const decl_index = opt_namespace.?.decls.keys()[i];
16220 var decl_vals = std.ArrayList(Value).init(sema.gpa);
16221 defer decl_vals.deinit();
16222
16223 var seen_namespaces = std.AutoHashMap(*Namespace, void).init(sema.gpa);
16224 defer seen_namespaces.deinit();
16225
16226 if (opt_namespace) |some| {
16227 try sema.typeInfoNamespaceDecls(block, decls_anon_decl.arena(), some, &decl_vals, &seen_namespaces);
16228 }
16229
16230 const new_decl = try decls_anon_decl.finish(
16231 try Type.Tag.array.create(decls_anon_decl.arena(), .{
16232 .len = decl_vals.items.len,
16233 .elem_type = declaration_ty,
16234 }),
16235 try Value.Tag.aggregate.create(
16236 decls_anon_decl.arena(),
16237 try decls_anon_decl.arena().dupe(Value, decl_vals.items),
16238 ),
16239 0, // default alignment
16240 );
16241 return try Value.Tag.slice.create(sema.arena, .{
16242 .ptr = try Value.Tag.decl_ref.create(sema.arena, new_decl),
16243 .len = try Value.Tag.int_u64.create(sema.arena, decl_vals.items.len),
16244 });
16245}
16246
16247fn typeInfoNamespaceDecls(
16248 sema: *Sema,
16249 block: *Block,
16250 decls_anon_decl: Allocator,
16251 namespace: *Namespace,
16252 decl_vals: *std.ArrayList(Value),
16253 seen_namespaces: *std.AutoHashMap(*Namespace, void),
16254) !void {
16255 const gop = try seen_namespaces.getOrPut(namespace);
16256 if (gop.found_existing) return;
16257 const decls = namespace.decls.keys();
16258 for (decls) |decl_index| {
1622416259 const decl = sema.mod.declPtr(decl_index);
16260 if (decl.kind == .@"usingnamespace") {
16261 try sema.mod.ensureDeclAnalyzed(decl_index);
16262 var buf: Value.ToTypeBuffer = undefined;
16263 const new_ns = decl.val.toType(&buf).getNamespace().?;
16264 try sema.typeInfoNamespaceDecls(block, decls_anon_decl, new_ns, decl_vals, seen_namespaces);
16265 continue;
16266 }
16267 if (decl.kind != .named) continue;
1622516268 const name_val = v: {
1622616269 var anon_decl = try block.startAnonDecl();
1622716270 defer anon_decl.deinit();
......@@ -16231,37 +16274,21 @@ fn typeInfoDecls(
1623116274 try Value.Tag.bytes.create(anon_decl.arena(), bytes[0 .. bytes.len + 1]),
1623216275 0, // default alignment
1623316276 );
16234 break :v try Value.Tag.slice.create(decls_anon_decl.arena(), .{
16235 .ptr = try Value.Tag.decl_ref.create(decls_anon_decl.arena(), new_decl),
16236 .len = try Value.Tag.int_u64.create(decls_anon_decl.arena(), bytes.len),
16277 break :v try Value.Tag.slice.create(decls_anon_decl, .{
16278 .ptr = try Value.Tag.decl_ref.create(decls_anon_decl, new_decl),
16279 .len = try Value.Tag.int_u64.create(decls_anon_decl, bytes.len),
1623716280 });
1623816281 };
1623916282
16240 const fields = try decls_anon_decl.arena().create([2]Value);
16283 const fields = try decls_anon_decl.create([2]Value);
1624116284 fields.* = .{
1624216285 //name: []const u8,
1624316286 name_val,
1624416287 //is_pub: bool,
1624516288 Value.makeBool(decl.is_pub),
1624616289 };
16247 decls_val.* = try Value.Tag.aggregate.create(decls_anon_decl.arena(), fields);
16290 try decl_vals.append(try Value.Tag.aggregate.create(decls_anon_decl, fields));
1624816291 }
16249
16250 const new_decl = try decls_anon_decl.finish(
16251 try Type.Tag.array.create(decls_anon_decl.arena(), .{
16252 .len = decls_vals.len,
16253 .elem_type = declaration_ty,
16254 }),
16255 try Value.Tag.aggregate.create(
16256 decls_anon_decl.arena(),
16257 try decls_anon_decl.arena().dupe(Value, decls_vals),
16258 ),
16259 0, // default alignment
16260 );
16261 return try Value.Tag.slice.create(sema.arena, .{
16262 .ptr = try Value.Tag.decl_ref.create(sema.arena, new_decl),
16263 .len = try Value.Tag.int_u64.create(sema.arena, decls_vals.len),
16264 });
1626516292}
1626616293
1626716294fn zirTypeof(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
test/behavior/type_info.zig+24
......@@ -566,3 +566,27 @@ test "value from struct @typeInfo default_value can be loaded at comptime" {
566566 try expect(@ptrCast(*const u8, a).* == 1);
567567 }
568568}
569
570test "@typeInfo decls and usingnamespace" {
571 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
572 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
573 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
574
575 const A = struct {
576 const x = 5;
577 const y = 34;
578
579 comptime {}
580 };
581 const B = struct {
582 usingnamespace A;
583 const z = 56;
584
585 test {}
586 };
587 const decls = @typeInfo(B).Struct.decls;
588 try expect(decls.len == 3);
589 try expectEqualStrings(decls[0].name, "x");
590 try expectEqualStrings(decls[1].name, "y");
591 try expectEqualStrings(decls[2].name, "z");
592}