Commit 3c08fe931a10618950c6af9e89226d1d9b20bbb9 | zig

author	Jacob G-W <jacoblevgw@gmail.com> 2023-07-25 11:15:59-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-07-25 16:19:08-07:00
log	3c08fe931a10618950c6af9e89226d1d9b20bbb9
tree	e745ce6e163c0af808adc8322a6c83e5ba426641
parent	972e70b7941561b10f9b3062dcd7b7a91016c546

make `@typeInfo` not return private decls

fixes #10731
Thanks @nektro for previous work in #14878

This change creates a small breaking change:
It removes the `is_pub` field of a decl in `@typeInfo`

10 files changed, 64 insertions(+), 52 deletions(-)

lib
- std
src
- Sema.zig
- codegen
  - llvm
    Builder.zig
- translate_c.zig
test
- behavior.zig
- behavior

lib/std/builtin.zig-1

...	@@ -437,7 +437,6 @@ pub const Type = union(enum) {	...	@@ -437,7 +437,6 @@ pub const Type = union(enum) {
437	/// therefore must be kept in sync with the compiler implementation.	437	/// therefore must be kept in sync with the compiler implementation.
438	pub const Declaration = struct {	438	pub const Declaration = struct {
439	name: []const u8,	439	name: []const u8,
440	is_pub: bool,
441	};	440	};
442	};	441	};
443		442

lib/std/meta.zig+14-16

 @@ -293,18 +293,18 @@ test "std.meta.declarations" {
     const E1 = enum {
         A,
-        fn a() void {}
+        pub fn a() void {}
     };
     const S1 = struct {
-        fn a() void {}
+        pub fn a() void {}
     };
     const U1 = union {
         a: u8,
-        fn a() void {}
+        pub fn a() void {}
     };
     const O1 = opaque {
-        fn a() void {}
+        pub fn a() void {}
     };
     const decls = comptime [_][]const Type.Declaration{
 @@ -333,15 +333,15 @@ test "std.meta.declarationInfo" {
     const E1 = enum {
         A,
-        fn a() void {}
+        pub fn a() void {}
     };
     const S1 = struct {
-        fn a() void {}
+        pub fn a() void {}
     };
     const U1 = union {
         a: u8,
-        fn a() void {}
+        pub fn a() void {}
     };
     const infos = comptime [_]Type.Declaration{
 @@ -352,7 +352,6 @@ test "std.meta.declarationInfo" {
     inline for (infos) |info| {
         try testing.expect(comptime mem.eql(u8, info.name, "a"));
-        try testing.expect(!info.is_pub);
     }
 }
 pub fn fields(comptime T: type) switch (@typeInfo(T)) {
 @@ -597,7 +596,6 @@ fn expectEqualEnum(expected: anytype, actual: @TypeOf(expected)) !void {
         if (expected_decls.len != actual_decls.len) return error.FailedTest;
         for (expected_decls, 0..) |expected_decl, i| {
             const actual_decl = actual_decls[i];
-            try testing.expectEqual(expected_decl.is_pub, actual_decl.is_pub);
             try testing.expectEqualStrings(expected_decl.name, actual_decl.name);
         }
     }
 @@ -644,21 +642,21 @@ pub fn DeclEnum(comptime T: type) type {
 test "std.meta.DeclEnum" {
     const A = struct {
-        const a: u8 = 0;
+        pub const a: u8 = 0;
     };
     const B = union {
         foo: void,
-        const a: u8 = 0;
+        pub const a: u8 = 0;
-        const b: void = {};
+        pub const b: void = {};
-        const c: f32 = 0;
+        pub const c: f32 = 0;
     };
     const C = enum {
         bar,
-        const a: u8 = 0;
+        pub const a: u8 = 0;
-        const b: void = {};
+        pub const b: void = {};
-        const c: f32 = 0;
+        pub const c: f32 = 0;
     };
     try expectEqualEnum(enum { a }, DeclEnum(A));
     try expectEqualEnum(enum { a, b, c }, DeclEnum(B));

lib/std/testing.zig+6-8

 @@ -1122,7 +1122,7 @@ pub fn checkAllAllocationFailures(backing_allocator: std.mem.Allocator, comptime
 pub fn refAllDecls(comptime T: type) void {
     if (!builtin.is_test) return;
     inline for (comptime std.meta.declarations(T)) |decl| {
-        if (decl.is_pub) _ = &@field(T, decl.name);
+        _ = &@field(T, decl.name);
     }
 }
 @@ -1131,14 +1131,12 @@ pub fn refAllDecls(comptime T: type) void {
 pub fn refAllDeclsRecursive(comptime T: type) void {
     if (!builtin.is_test) return;
     inline for (comptime std.meta.declarations(T)) |decl| {
-        if (decl.is_pub) {
+        if (@TypeOf(@field(T, decl.name)) == type) {
-            if (@TypeOf(@field(T, decl.name)) == type) {
+            switch (@typeInfo(@field(T, decl.name))) {
-                switch (@typeInfo(@field(T, decl.name))) {
+                .Struct, .Enum, .Union, .Opaque => refAllDeclsRecursive(@field(T, decl.name)),
-                    .Struct, .Enum, .Union, .Opaque => refAllDeclsRecursive(@field(T, decl.name)),
+                else => {},
-                    else => {},
-                }
             }
-            _ = &@field(T, decl.name);
         }
+        _ = &@field(T, decl.name);
     }
 }

src/Sema.zig+1-3

...	@@ -17526,7 +17526,7 @@ fn typeInfoNamespaceDecls(	...	@@ -17526,7 +17526,7 @@ fn typeInfoNamespaceDecls(
17526	try sema.typeInfoNamespaceDecls(block, new_ns, declaration_ty, decl_vals, seen_namespaces);	17526	try sema.typeInfoNamespaceDecls(block, new_ns, declaration_ty, decl_vals, seen_namespaces);
17527	continue;	17527	continue;
17528	}	17528	}
17529	if (decl.kind != .named) continue;	17529	if (decl.kind != .named or !decl.is_pub) continue;
17530	const name_val = v: {	17530	const name_val = v: {
17531	var anon_decl = try block.startAnonDecl();	17531	var anon_decl = try block.startAnonDecl();
17532	defer anon_decl.deinit();	17532	defer anon_decl.deinit();
...	@@ -17554,8 +17554,6 @@ fn typeInfoNamespaceDecls(	...	@@ -17554,8 +17554,6 @@ fn typeInfoNamespaceDecls(
17554	const fields = .{	17554	const fields = .{
17555	//name: []const u8,	17555	//name: []const u8,
17556	name_val,	17556	name_val,
17557	//is_pub: bool,
17558	Value.makeBool(decl.is_pub).toIntern(),
17559	};	17557	};
17560	try decl_vals.append(try mod.intern(.{ .aggregate = .{	17558	try decl_vals.append(try mod.intern(.{ .aggregate = .{
17561	.ty = declaration_ty.toIntern(),	17559	.ty = declaration_ty.toIntern(),

src/codegen/llvm/Builder.zig-1

...	@@ -1159,7 +1159,6 @@ pub const Attribute = union(Kind) {	...	@@ -1159,7 +1159,6 @@ pub const Attribute = union(Kind) {
1159	var any = false;	1159	var any = false;
1160	var remaining: Int = @bitCast(fpclass);	1160	var remaining: Int = @bitCast(fpclass);
1161	inline for (@typeInfo(FpClass).Struct.decls) \|decl\| {	1161	inline for (@typeInfo(FpClass).Struct.decls) \|decl\| {
1162	if (!decl.is_pub) continue;
1163	const pattern: Int = @bitCast(@field(FpClass, decl.name));	1162	const pattern: Int = @bitCast(@field(FpClass, decl.name));
1164	if (remaining & pattern == pattern) {	1163	if (remaining & pattern == pattern) {
1165	if (!any) {	1164	if (!any) {

src/translate_c.zig+5-8

 @@ -408,13 +408,11 @@ pub fn translate(
     }
     inline for (@typeInfo(std.zig.c_builtins).Struct.decls) |decl| {
-        if (decl.is_pub) {
+        const builtin = try Tag.pub_var_simple.create(arena, .{
-            const builtin = try Tag.pub_var_simple.create(arena, .{
+            .name = decl.name,
-                .name = decl.name,
+            .init = try Tag.import_c_builtin.create(arena, decl.name),
-                .init = try Tag.import_c_builtin.create(arena, decl.name),
+        });
-            });
+        try addTopLevelDecl(&context, decl.name, builtin);
-            try addTopLevelDecl(&context, decl.name, builtin);
-        }
     }
     try prepopulateGlobalNameTable(ast_unit, &context);
 @@ -2120,7 +2118,6 @@ fn transImplicitCastExpr(
 fn isBuiltinDefined(name: []const u8) bool {
     inline for (@typeInfo(std.zig.c_builtins).Struct.decls) |decl| {
-        if (!decl.is_pub) continue;
         if (std.mem.eql(u8, name, decl.name)) return true;
     }
     return false;

test/behavior.zig+1

...	@@ -222,6 +222,7 @@ test {	...	@@ -222,6 +222,7 @@ test {
222	_ = @import("behavior/tuple_declarations.zig");	222	_ = @import("behavior/tuple_declarations.zig");
223	_ = @import("behavior/type.zig");	223	_ = @import("behavior/type.zig");
224	_ = @import("behavior/type_info.zig");	224	_ = @import("behavior/type_info.zig");
		225	_ = @import("behavior/type_info_only_pub_decls.zig");
225	_ = @import("behavior/typename.zig");	226	_ = @import("behavior/typename.zig");
226	_ = @import("behavior/undefined.zig");	227	_ = @import("behavior/undefined.zig");
227	_ = @import("behavior/underscore.zig");	228	_ = @import("behavior/underscore.zig");

test/behavior/eval.zig+1-1

...	@@ -959,7 +959,7 @@ test "debug variable type resolved through indirect zero-bit types" {	...	@@ -959,7 +959,7 @@ test "debug variable type resolved through indirect zero-bit types" {
959	test "const local with comptime init through array init" {	959	test "const local with comptime init through array init" {
960	const E1 = enum {	960	const E1 = enum {
961	A,	961	A,
962	fn a() void {}	962	pub fn a() void {}
963	};	963	};
964		964
965	const S = struct {	965	const S = struct {

test/behavior/type_info.zig+13-14

 @@ -321,8 +321,7 @@ fn testPackedStruct() !void {
     try expect(struct_info.Struct.fields[2].default_value == null);
     try expect(@as(*align(1) const u32, @ptrCast(struct_info.Struct.fields[3].default_value.?)).* == 4);
     try expect(struct_info.Struct.fields[3].alignment == 0);
-    try expect(struct_info.Struct.decls.len == 2);
+    try expect(struct_info.Struct.decls.len == 1);
-    try expect(struct_info.Struct.decls[0].is_pub);
 }
 const TestPackedStruct = packed struct {
 @@ -344,8 +343,8 @@ test "type info: opaque info" {
 fn testOpaque() !void {
     const Foo = opaque {
-        const A = 1;
+        pub const A = 1;
-        fn b() void {}
+        pub fn b() void {}
     };
     const foo_info = @typeInfo(Foo);
 @@ -514,11 +513,11 @@ test "Declarations are returned in declaration order" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     const S = struct {
-        const a = 1;
+        pub const a = 1;
-        const b = 2;
+        pub const b = 2;
-        const c = 3;
+        pub const c = 3;
-        const d = 4;
+        pub const d = 4;
-        const e = 5;
+        pub const e = 5;
     };
     const d = @typeInfo(S).Struct.decls;
     try expect(std.mem.eql(u8, d[0].name, "a"));
 @@ -553,7 +552,7 @@ test "typeInfo resolves usingnamespace declarations" {
     };
     const B = struct {
-        const f0 = 42;
+        pub const f0 = 42;
         usingnamespace A;
     };
 @@ -574,14 +573,14 @@ test "@typeInfo decls and usingnamespace" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const A = struct {
-        const x = 5;
+        pub const x = 5;
-        const y = 34;
+        pub const y = 34;
         comptime {}
     };
     const B = struct {
         usingnamespace A;
-        const z = 56;
+        pub const z = 56;
         test {}
     };
 @@ -594,7 +593,7 @@ test "@typeInfo decls and usingnamespace" {
 test "@typeInfo decls ignore dependency loops" {
     const S = struct {
-        fn Def(comptime T: type) type {
+        pub fn Def(comptime T: type) type {
             std.debug.assert(@typeInfo(T).Struct.decls.len == 1);
             return struct {
                 const foo = u32;

test/behavior/type_info_only_pub_decls.zig created+23

...	@@ -0,0 +1,23 @@
1	const std = @import("std");
2	const other = struct {
3	const std = @import("std");
4
5	pub const Enum = enum {
6	a,
7	b,
8	c,
9	};
10
11	pub const Struct = struct {
12	foo: i32,
13	};
14	};
15
16	test {
17	const ti = @typeInfo(other);
18	const decls = ti.Struct.decls;
19
20	try std.testing.expectEqual(2, decls.len);
21	try std.testing.expectEqualStrings("Enum", decls[0].name);
22	try std.testing.expectEqualStrings("Struct", decls[1].name);
23	}