Commit ca9e1760e8
Changed files (9)
src
lib/std/zig/parser_test.zig
@@ -5198,6 +5198,382 @@ test "zig fmt: while continue expr" {
});
}
+test "zig fmt: canonicalize symbols (simple)" {
+ try testTransform(
+ \\const val_normal: Normal = .{};
+ \\const @"val_unesc_me": @"UnescMe" = .{};
+ \\const @"val_esc!": @"Esc!" = .{};
+ \\
+ \\fn fnNormal() void {}
+ \\fn @"fnUnescMe"() void {}
+ \\fn @"fnEsc!"() void {}
+ \\
+ \\extern fn protoNormal() void;
+ \\extern fn @"protoUnescMe"() void;
+ \\extern fn @"protoEsc!"() void;
+ \\
+ \\fn fnWithArgs(normal: Normal, @"unesc_me": @"UnescMe", @"esc!": @"Esc!") void {
+ \\ _ = normal;
+ \\ _ = @"unesc_me";
+ \\ _ = @"esc!";
+ \\}
+ \\
+ \\const Normal = struct {};
+ \\const @"UnescMe" = struct {
+ \\ @"x": @"X",
+ \\ const X = union(@"EnumUnesc") {
+ \\ normal,
+ \\ @"unesc_me",
+ \\ @"esc!",
+ \\ };
+ \\ const @"EnumUnesc" = enum {
+ \\ normal,
+ \\ @"unesc_me",
+ \\ @"esc!",
+ \\ };
+ \\};
+ \\const @"Esc!" = struct {
+ \\ normal: bool = false,
+ \\ @"unesc_me": bool = false,
+ \\ @"esc!": bool = false,
+ \\};
+ \\
+ \\pub fn main() void {
+ \\ _ = val_normal;
+ \\ _ = @"val_normal";
+ \\ _ = val_unesc_me;
+ \\ _ = @"val_unesc_me";
+ \\ _ = @"val_esc!";
+ \\
+ \\ fnNormal();
+ \\ @"fnNormal"();
+ \\ fnUnescMe();
+ \\ @"fnUnescMe"();
+ \\ @"fnEsc!"();
+ \\
+ \\ fnWithArgs(1, Normal{}, UnescMe{}, @"Esc!"{});
+ \\ fnWithArgs(1, @"Normal"{}, @"UnescMe"{}, @"Esc!"{});
+ \\ fnWithArgs(1, @"Normal"{}, @"Normal"{}, @"Esc!"{});
+ \\
+ \\ const local_val1: @"Normal" = .{};
+ \\ const @"local_val2": UnescMe = .{
+ \\ .@"x" = .@"unesc_me",
+ \\ };
+ \\ fnWithArgs(@"local_val1", @"local_val2", .{ .@"normal" = true, .@"unesc_me" = true, .@"esc!" = true });
+ \\ fnWithArgs(local_val1, local_val2, .{ .normal = true, .unesc_me = true, .@"esc!" = true });
+ \\
+ \\ var x: u8 = 'x';
+ \\ switch (@"x") {
+ \\ @"x" => {},
+ \\ }
+ \\
+ \\ _ = @import("std"); // Don't mess with @builtins
+ \\ // @"comment"
+ \\}
+ \\
+ ,
+ \\const val_normal: Normal = .{};
+ \\const val_unesc_me: UnescMe = .{};
+ \\const @"val_esc!": @"Esc!" = .{};
+ \\
+ \\fn fnNormal() void {}
+ \\fn fnUnescMe() void {}
+ \\fn @"fnEsc!"() void {}
+ \\
+ \\extern fn protoNormal() void;
+ \\extern fn protoUnescMe() void;
+ \\extern fn @"protoEsc!"() void;
+ \\
+ \\fn fnWithArgs(normal: Normal, unesc_me: UnescMe, @"esc!": @"Esc!") void {
+ \\ _ = normal;
+ \\ _ = unesc_me;
+ \\ _ = @"esc!";
+ \\}
+ \\
+ \\const Normal = struct {};
+ \\const UnescMe = struct {
+ \\ x: X,
+ \\ const X = union(EnumUnesc) {
+ \\ normal,
+ \\ unesc_me,
+ \\ @"esc!",
+ \\ };
+ \\ const EnumUnesc = enum {
+ \\ normal,
+ \\ unesc_me,
+ \\ @"esc!",
+ \\ };
+ \\};
+ \\const @"Esc!" = struct {
+ \\ normal: bool = false,
+ \\ unesc_me: bool = false,
+ \\ @"esc!": bool = false,
+ \\};
+ \\
+ \\pub fn main() void {
+ \\ _ = val_normal;
+ \\ _ = val_normal;
+ \\ _ = val_unesc_me;
+ \\ _ = val_unesc_me;
+ \\ _ = @"val_esc!";
+ \\
+ \\ fnNormal();
+ \\ fnNormal();
+ \\ fnUnescMe();
+ \\ fnUnescMe();
+ \\ @"fnEsc!"();
+ \\
+ \\ fnWithArgs(1, Normal{}, UnescMe{}, @"Esc!"{});
+ \\ fnWithArgs(1, Normal{}, UnescMe{}, @"Esc!"{});
+ \\ fnWithArgs(1, Normal{}, Normal{}, @"Esc!"{});
+ \\
+ \\ const local_val1: Normal = .{};
+ \\ const local_val2: UnescMe = .{
+ \\ .x = .unesc_me,
+ \\ };
+ \\ fnWithArgs(local_val1, local_val2, .{ .normal = true, .unesc_me = true, .@"esc!" = true });
+ \\ fnWithArgs(local_val1, local_val2, .{ .normal = true, .unesc_me = true, .@"esc!" = true });
+ \\
+ \\ var x: u8 = 'x';
+ \\ switch (x) {
+ \\ x => {},
+ \\ }
+ \\
+ \\ _ = @import("std"); // Don't mess with @builtins
+ \\ // @"comment"
+ \\}
+ \\
+ );
+}
+
+// Contextually unescape when shadowing primitive types and values.
+test "zig fmt: canonicalize symbols (primitive types)" {
+ try testTransform(
+ \\const @"anyopaque" = struct {
+ \\ @"u8": @"type" = true,
+ \\ @"_": @"false" = @"true",
+ \\ const @"type" = bool;
+ \\ const @"false" = bool;
+ \\ const @"true" = false;
+ \\};
+ \\
+ \\const U = union(@"null") {
+ \\ @"type",
+ \\ const @"null" = enum {
+ \\ @"type",
+ \\ };
+ \\};
+ \\
+ \\test {
+ \\ const E = enum { @"anyopaque" };
+ \\ _ = U{ .@"type" = {} };
+ \\ _ = U.@"type";
+ \\ _ = E.@"anyopaque";
+ \\}
+ \\
+ \\fn @"i10"(@"void": @"anyopaque", @"type": @"anyopaque".@"type") error{@"null"}!void {
+ \\ var @"f32" = @"void";
+ \\ @"f32".@"u8" = false;
+ \\ _ = @"type";
+ \\ _ = type;
+ \\ if (@"f32".@"u8") {
+ \\ return @"i10"(.{ .@"u8" = true, .@"_" = false }, false);
+ \\ } else {
+ \\ return error.@"null";
+ \\ }
+ \\}
+ \\
+ \\test @"i10" {
+ \\ try @"i10"(.{}, true);
+ \\ _ = @"void": while (null) |@"u3"| {
+ \\ break :@"void" @"u3";
+ \\ };
+ \\ _ = @"void": {
+ \\ break :@"void";
+ \\ };
+ \\ for ("hi") |@"u3", @"i4"| {
+ \\ _ = @"u3";
+ \\ _ = @"i4";
+ \\ }
+ \\ if (false) {} else |@"bool"| {
+ \\ _ = @"bool";
+ \\ }
+ \\}
+ \\
+ ,
+ \\const @"anyopaque" = struct {
+ \\ u8: @"type" = true,
+ \\ _: @"false" = @"true",
+ \\ const @"type" = bool;
+ \\ const @"false" = bool;
+ \\ const @"true" = false;
+ \\};
+ \\
+ \\const U = union(@"null") {
+ \\ type,
+ \\ const @"null" = enum {
+ \\ type,
+ \\ };
+ \\};
+ \\
+ \\test {
+ \\ const E = enum { anyopaque };
+ \\ _ = U{ .type = {} };
+ \\ _ = U.type;
+ \\ _ = E.anyopaque;
+ \\}
+ \\
+ \\fn @"i10"(@"void": @"anyopaque", @"type": @"anyopaque".type) error{null}!void {
+ \\ var @"f32" = @"void";
+ \\ @"f32".u8 = false;
+ \\ _ = @"type";
+ \\ _ = type;
+ \\ if (@"f32".u8) {
+ \\ return @"i10"(.{ .u8 = true, ._ = false }, false);
+ \\ } else {
+ \\ return error.null;
+ \\ }
+ \\}
+ \\
+ \\test @"i10" {
+ \\ try @"i10"(.{}, true);
+ \\ _ = void: while (null) |@"u3"| {
+ \\ break :void @"u3";
+ \\ };
+ \\ _ = void: {
+ \\ break :void;
+ \\ };
+ \\ for ("hi") |@"u3", @"i4"| {
+ \\ _ = @"u3";
+ \\ _ = @"i4";
+ \\ }
+ \\ if (false) {} else |@"bool"| {
+ \\ _ = @"bool";
+ \\ }
+ \\}
+ \\
+ );
+}
+
+// Never unescape names spelled like keywords.
+test "zig fmt: canonicalize symbols (keywords)" {
+ try testCanonical(
+ \\const @"enum" = struct {
+ \\ @"error": @"struct" = true,
+ \\ const @"struct" = bool;
+ \\};
+ \\
+ \\fn @"usingnamespace"(@"union": @"enum") error{@"try"}!void {
+ \\ var @"struct" = @"union";
+ \\ @"struct".@"error" = false;
+ \\ if (@"struct".@"error") {
+ \\ return @"usingnamespace"(.{ .@"error" = false });
+ \\ } else {
+ \\ return error.@"try";
+ \\ }
+ \\}
+ \\
+ \\test @"usingnamespace" {
+ \\ try @"usingnamespace"(.{});
+ \\ _ = @"return": {
+ \\ break :@"return" 4;
+ \\ };
+ \\}
+ \\
+ );
+}
+
+// Normalize \xNN and \u{NN} escapes and unicode inside @"" escapes.
+test "zig fmt: canonicalize symbols (character escapes)" {
+ try testTransform(
+ \\const @"\x46\x6f\x6f\x64" = struct {
+ \\ @"\x62\x61\x72\x6E": @"\x43\x72\x61\x62" = false,
+ \\ @"\u{67}\u{6C}o\u{70}\xFF": @"Cra\x62" = false,
+ \\ @"\x65\x72\x72\x6F\x72": Crab = true,
+ \\ @"\x74\x72\x79": Crab = true,
+ \\ @"\u{74}\u{79}\u{70}\u{65}": @"any\u{6F}\u{70}\u{61}\u{71}\u{75}\u{65}",
+ \\
+ \\ const @"\x43\x72\x61\x62" = bool;
+ \\ const @"\x61\x6E\x79\x6F\x70\x61que" = void;
+ \\};
+ \\
+ \\test "unicode" {
+ \\ const @"cąbbäge ⚡" = 2;
+ \\ _ = @"cąbbäge ⚡";
+ \\ const @"\u{01f422} friend\u{f6}" = 4;
+ \\ _ = @"🐢 friendö";
+ \\}
+ \\
+ ,
+ \\const Food = struct {
+ \\ barn: Crab = false,
+ \\ @"glop\xFF": Crab = false,
+ \\ @"error": Crab = true,
+ \\ @"try": Crab = true,
+ \\ type: @"anyopaque",
+ \\
+ \\ const Crab = bool;
+ \\ const @"anyopaque" = void;
+ \\};
+ \\
+ \\test "unicode" {
+ \\ const @"cąbbäge ⚡" = 2;
+ \\ _ = @"cąbbäge ⚡";
+ \\ const @"\u{01f422} friend\u{f6}" = 4;
+ \\ _ = @"🐢 friendö";
+ \\}
+ \\
+ );
+}
+
+test "zig fmt: canonicalize symbols (asm)" {
+ try testTransform(
+ \\test "asm" {
+ \\ const @"null" = usize;
+ \\ const @"try": usize = 808;
+ \\ const arg: usize = 2;
+ \\ _ = asm volatile ("syscall"
+ \\ : [@"void"] "={rax}" (-> @"null"),
+ \\ : [@"error"] "{rax}" (@"try"),
+ \\ [@"arg1"] "{rdi}" (arg),
+ \\ [arg2] "{rsi}" (arg),
+ \\ [arg3] "{rdx}" (arg),
+ \\ : "rcx", "r11"
+ \\ );
+ \\
+ \\ const @"false": usize = 10;
+ \\ const @"true" = "explode";
+ \\ _ = asm volatile (@"true"
+ \\ : [one] "={rax}" (@"false"),
+ \\ : [two] "{rax}" (@"false"),
+ \\ );
+ \\}
+ \\
+ ,
+ \\test "asm" {
+ \\ const @"null" = usize;
+ \\ const @"try": usize = 808;
+ \\ const arg: usize = 2;
+ \\ _ = asm volatile ("syscall"
+ \\ : [void] "={rax}" (-> @"null"),
+ \\ : [@"error"] "{rax}" (@"try"),
+ \\ [arg1] "{rdi}" (arg),
+ \\ [arg2] "{rsi}" (arg),
+ \\ [arg3] "{rdx}" (arg),
+ \\ : "rcx", "r11"
+ \\ );
+ \\
+ \\ const @"false": usize = 10;
+ \\ const @"true" = "explode";
+ \\ _ = asm volatile (@"true"
+ \\ : [one] "={rax}" (false),
+ \\ : [two] "{rax}" (@"false"),
+ \\ );
+ \\}
+ \\
+ );
+}
+
test "zig fmt: error for missing sentinel value in sentinel slice" {
try testError(
\\const foo = foo[0..:];
lib/std/zig/primitives.zig
@@ -0,0 +1,63 @@
+const std = @import("std");
+
+/// Set of primitive type and value names.
+/// Does not include `_` or integer type names.
+pub const names = std.ComptimeStringMap(void, .{
+ .{"anyerror"},
+ .{"anyframe"},
+ .{"anyopaque"},
+ .{"bool"},
+ .{"c_int"},
+ .{"c_long"},
+ .{"c_longdouble"},
+ .{"c_longlong"},
+ .{"c_short"},
+ .{"c_uint"},
+ .{"c_ulong"},
+ .{"c_ulonglong"},
+ .{"c_ushort"},
+ .{"comptime_float"},
+ .{"comptime_int"},
+ .{"f128"},
+ .{"f16"},
+ .{"f32"},
+ .{"f64"},
+ .{"f80"},
+ .{"false"},
+ .{"isize"},
+ .{"noreturn"},
+ .{"null"},
+ .{"true"},
+ .{"type"},
+ .{"undefined"},
+ .{"usize"},
+ .{"void"},
+});
+
+/// Returns true if a name matches a primitive type or value, excluding `_`.
+/// Integer type names like `u8` or `i32` are only matched for syntax,
+/// so this will still return true when they have an oversized bit count
+/// or leading zeroes.
+pub fn isPrimitive(name: []const u8) bool {
+ if (names.get(name) != null) return true;
+ if (name.len < 2) return false;
+ const first_c = name[0];
+ if (first_c != 'i' and first_c != 'u') return false;
+ for (name[1..]) |c| switch (c) {
+ '0'...'9' => {},
+ else => return false,
+ };
+ return true;
+}
+
+test "isPrimitive" {
+ const expect = std.testing.expect;
+ try expect(!isPrimitive(""));
+ try expect(!isPrimitive("_"));
+ try expect(!isPrimitive("haberdasher"));
+ try expect(isPrimitive("bool"));
+ try expect(isPrimitive("false"));
+ try expect(isPrimitive("comptime_float"));
+ try expect(isPrimitive("u1"));
+ try expect(isPrimitive("i99999999999999"));
+}
lib/std/zig/render.zig
@@ -5,6 +5,7 @@ const Allocator = std.mem.Allocator;
const meta = std.meta;
const Ast = std.zig.Ast;
const Token = std.zig.Token;
+const primitives = std.zig.primitives;
const indent_delta = 4;
const asm_indent_delta = 2;
@@ -152,8 +153,10 @@ fn renderMember(gpa: Allocator, ais: *Ais, tree: Ast, decl: Ast.Node.Index, spac
const test_token = main_tokens[decl];
try renderToken(ais, tree, test_token, .space);
const test_name_tag = token_tags[test_token + 1];
- if (test_name_tag == .string_literal or test_name_tag == .identifier) {
- try renderToken(ais, tree, test_token + 1, .space);
+ switch (test_name_tag) {
+ .string_literal => try renderToken(ais, tree, test_token + 1, .space),
+ .identifier => try renderIdentifier(ais, tree, test_token + 1, .space, .preserve_when_shadowing),
+ else => {},
}
try renderExpression(gpa, ais, tree, datas[decl].rhs, space);
},
@@ -192,11 +195,10 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
const lexeme = tokenSliceForRender(tree, token_index);
if (mem.eql(u8, lexeme, "c_void")) {
try ais.writer().writeAll("anyopaque");
+ return renderSpace(ais, tree, token_index, lexeme.len, space);
} else {
- try ais.writer().writeAll(lexeme);
+ return renderIdentifier(ais, tree, token_index, space, .preserve_when_shadowing);
}
-
- return renderSpace(ais, tree, token_index, lexeme.len, space);
},
.number_literal,
@@ -226,7 +228,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
.error_value => {
try renderToken(ais, tree, main_tokens[node], .none);
try renderToken(ais, tree, main_tokens[node] + 1, .none);
- return renderToken(ais, tree, main_tokens[node] + 2, space);
+ return renderIdentifier(ais, tree, main_tokens[node] + 2, space, .eagerly_unquote);
},
.block_two,
@@ -256,7 +258,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
try renderToken(ais, tree, defer_token, .space);
if (payload_token != 0) {
try renderToken(ais, tree, payload_token - 1, .none); // |
- try renderToken(ais, tree, payload_token, .none); // identifier
+ try renderIdentifier(ais, tree, payload_token, .none, .preserve_when_shadowing); // identifier
try renderToken(ais, tree, payload_token + 1, .space); // |
}
return renderExpression(gpa, ais, tree, expr, space);
@@ -294,7 +296,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
if (token_tags[fallback_first - 1] == .pipe) {
try renderToken(ais, tree, main_token, .space); // catch keyword
try renderToken(ais, tree, main_token + 1, .none); // pipe
- try renderToken(ais, tree, main_token + 2, .none); // payload identifier
+ try renderIdentifier(ais, tree, main_token + 2, .none, .preserve_when_shadowing); // payload identifier
try renderToken(ais, tree, main_token + 3, after_op_space); // pipe
} else {
assert(token_tags[fallback_first - 1] == .keyword_catch);
@@ -320,7 +322,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
ais.pushIndentOneShot();
}
- try renderToken(ais, tree, main_token, .none);
+ try renderToken(ais, tree, main_token, .none); // .
// This check ensures that zag() is indented in the following example:
// const x = foo
@@ -331,7 +333,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
ais.pushIndentOneShot();
}
- return renderToken(ais, tree, field_access.rhs, space);
+ return renderIdentifier(ais, tree, field_access.rhs, space, .eagerly_unquote); // field
},
.error_union,
@@ -514,11 +516,11 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
} else if (label_token != 0 and target == 0) {
try renderToken(ais, tree, main_token, .space); // break keyword
try renderToken(ais, tree, label_token - 1, .none); // colon
- try renderToken(ais, tree, label_token, space); // identifier
+ try renderIdentifier(ais, tree, label_token, space, .eagerly_unquote); // identifier
} else if (label_token != 0 and target != 0) {
try renderToken(ais, tree, main_token, .space); // break keyword
try renderToken(ais, tree, label_token - 1, .none); // colon
- try renderToken(ais, tree, label_token, .space); // identifier
+ try renderIdentifier(ais, tree, label_token, .space, .eagerly_unquote); // identifier
try renderExpression(gpa, ais, tree, target, space);
}
},
@@ -529,7 +531,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
if (label != 0) {
try renderToken(ais, tree, main_token, .space); // continue
try renderToken(ais, tree, label - 1, .none); // :
- return renderToken(ais, tree, label, space); // label
+ return renderIdentifier(ais, tree, label, space, .eagerly_unquote); // label
} else {
return renderToken(ais, tree, main_token, space); // continue
}
@@ -590,7 +592,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
// There is exactly one member and no trailing comma or
// comments, so render without surrounding spaces: `error{Foo}`
try renderToken(ais, tree, lbrace, .none);
- try renderToken(ais, tree, lbrace + 1, .none); // identifier
+ try renderIdentifier(ais, tree, lbrace + 1, .none, .eagerly_unquote); // identifier
return renderToken(ais, tree, rbrace, space);
} else if (token_tags[rbrace - 1] == .comma) {
// There is a trailing comma so render each member on a new line.
@@ -601,7 +603,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
if (i > lbrace + 1) try renderExtraNewlineToken(ais, tree, i);
switch (token_tags[i]) {
.doc_comment => try renderToken(ais, tree, i, .newline),
- .identifier => try renderToken(ais, tree, i, .comma),
+ .identifier => try renderIdentifier(ais, tree, i, .comma, .eagerly_unquote),
.comma => {},
else => unreachable,
}
@@ -615,7 +617,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
while (i < rbrace) : (i += 1) {
switch (token_tags[i]) {
.doc_comment => unreachable, // TODO
- .identifier => try renderToken(ais, tree, i, .comma_space),
+ .identifier => try renderIdentifier(ais, tree, i, .comma_space, .eagerly_unquote),
.comma => {},
else => unreachable,
}
@@ -702,7 +704,7 @@ fn renderExpression(gpa: Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
.enum_literal => {
try renderToken(ais, tree, main_tokens[node] - 1, .none); // .
- return renderToken(ais, tree, main_tokens[node], space); // name
+ return renderIdentifier(ais, tree, main_tokens[node], space, .eagerly_unquote); // name
},
.fn_decl => unreachable,
@@ -887,7 +889,7 @@ fn renderAsmOutput(
const symbolic_name = main_tokens[asm_output];
try renderToken(ais, tree, symbolic_name - 1, .none); // lbracket
- try renderToken(ais, tree, symbolic_name, .none); // ident
+ try renderIdentifier(ais, tree, symbolic_name, .none, .eagerly_unquote); // ident
try renderToken(ais, tree, symbolic_name + 1, .space); // rbracket
try renderToken(ais, tree, symbolic_name + 2, .space); // "constraint"
try renderToken(ais, tree, symbolic_name + 3, .none); // lparen
@@ -897,7 +899,7 @@ fn renderAsmOutput(
try renderExpression(gpa, ais, tree, datas[asm_output].lhs, Space.none);
return renderToken(ais, tree, datas[asm_output].rhs, space); // rparen
} else {
- try renderToken(ais, tree, symbolic_name + 4, .none); // ident
+ try renderIdentifier(ais, tree, symbolic_name + 4, .none, .eagerly_unquote); // ident
return renderToken(ais, tree, symbolic_name + 5, space); // rparen
}
}
@@ -916,7 +918,7 @@ fn renderAsmInput(
const symbolic_name = main_tokens[asm_input];
try renderToken(ais, tree, symbolic_name - 1, .none); // lbracket
- try renderToken(ais, tree, symbolic_name, .none); // ident
+ try renderIdentifier(ais, tree, symbolic_name, .none, .eagerly_unquote); // ident
try renderToken(ais, tree, symbolic_name + 1, .space); // rbracket
try renderToken(ais, tree, symbolic_name + 2, .space); // "constraint"
try renderToken(ais, tree, symbolic_name + 3, .none); // lparen
@@ -955,7 +957,7 @@ fn renderVarDecl(gpa: Allocator, ais: *Ais, tree: Ast, var_decl: Ast.full.VarDec
Space.space
else
Space.none;
- try renderToken(ais, tree, var_decl.ast.mut_token + 1, name_space); // name
+ try renderIdentifier(ais, tree, var_decl.ast.mut_token + 1, name_space, .preserve_when_shadowing); // name
if (var_decl.ast.type_node != 0) {
try renderToken(ais, tree, var_decl.ast.mut_token + 2, Space.space); // :
@@ -1055,7 +1057,7 @@ fn renderWhile(gpa: Allocator, ais: *Ais, tree: Ast, while_node: Ast.full.While,
const token_tags = tree.tokens.items(.tag);
if (while_node.label_token) |label| {
- try renderToken(ais, tree, label, .none); // label
+ try renderIdentifier(ais, tree, label, .none, .eagerly_unquote); // label
try renderToken(ais, tree, label + 1, .space); // :
}
@@ -1080,11 +1082,11 @@ fn renderWhile(gpa: Allocator, ais: *Ais, tree: Ast, while_node: Ast.full.While,
break :blk payload_token;
}
};
- try renderToken(ais, tree, ident, .none); // identifier
+ try renderIdentifier(ais, tree, ident, .none, .preserve_when_shadowing); // identifier
const pipe = blk: {
if (token_tags[ident + 1] == .comma) {
try renderToken(ais, tree, ident + 1, .space); // ,
- try renderToken(ais, tree, ident + 2, .none); // index
+ try renderIdentifier(ais, tree, ident + 2, .none, .preserve_when_shadowing); // index
break :blk ident + 3;
} else {
break :blk ident + 1;
@@ -1127,7 +1129,7 @@ fn renderWhile(gpa: Allocator, ais: *Ais, tree: Ast, while_node: Ast.full.While,
if (while_node.error_token) |error_token| {
try renderToken(ais, tree, while_node.else_token, .space); // else
try renderToken(ais, tree, error_token - 1, .none); // |
- try renderToken(ais, tree, error_token, .none); // identifier
+ try renderIdentifier(ais, tree, error_token, .none, .preserve_when_shadowing); // identifier
last_else_token = error_token + 1; // |
}
@@ -1163,10 +1165,10 @@ fn renderContainerField(
try renderToken(ais, tree, t, .space); // comptime
}
if (field.ast.type_expr == 0 and field.ast.value_expr == 0) {
- return renderTokenComma(ais, tree, field.ast.name_token, space); // name
+ return renderIdentifierComma(ais, tree, field.ast.name_token, space, .eagerly_unquote); // name
}
if (field.ast.type_expr != 0 and field.ast.value_expr == 0) {
- try renderToken(ais, tree, field.ast.name_token, .none); // name
+ try renderIdentifier(ais, tree, field.ast.name_token, .none, .eagerly_unquote); // name
try renderToken(ais, tree, field.ast.name_token + 1, .space); // :
if (field.ast.align_expr != 0) {
@@ -1182,12 +1184,12 @@ fn renderContainerField(
}
}
if (field.ast.type_expr == 0 and field.ast.value_expr != 0) {
- try renderToken(ais, tree, field.ast.name_token, .space); // name
+ try renderIdentifier(ais, tree, field.ast.name_token, .space, .eagerly_unquote); // name
try renderToken(ais, tree, field.ast.name_token + 1, .space); // =
return renderExpressionComma(gpa, ais, tree, field.ast.value_expr, space); // value
}
- try renderToken(ais, tree, field.ast.name_token, .none); // name
+ try renderIdentifier(ais, tree, field.ast.name_token, .none, .eagerly_unquote); // name
try renderToken(ais, tree, field.ast.name_token + 1, .space); // :
try renderExpression(gpa, ais, tree, field.ast.type_expr, .space); // type
@@ -1294,7 +1296,7 @@ fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProt
const after_fn_token = fn_proto.ast.fn_token + 1;
const lparen = if (token_tags[after_fn_token] == .identifier) blk: {
try renderToken(ais, tree, fn_proto.ast.fn_token, .space); // fn
- try renderToken(ais, tree, after_fn_token, .none); // name
+ try renderIdentifier(ais, tree, after_fn_token, .none, .preserve_when_shadowing); // name
break :blk after_fn_token + 1;
} else blk: {
try renderToken(ais, tree, fn_proto.ast.fn_token, .space); // fn
@@ -1383,7 +1385,7 @@ fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProt
if (token_tags[last_param_token] == .identifier and
token_tags[last_param_token + 1] == .colon)
{
- try renderToken(ais, tree, last_param_token, .none); // name
+ try renderIdentifier(ais, tree, last_param_token, .none, .preserve_when_shadowing); // name
last_param_token += 1;
try renderToken(ais, tree, last_param_token, .space); // :
last_param_token += 1;
@@ -1432,7 +1434,7 @@ fn renderFnProto(gpa: Allocator, ais: *Ais, tree: Ast, fn_proto: Ast.full.FnProt
if (token_tags[last_param_token] == .identifier and
token_tags[last_param_token + 1] == .colon)
{
- try renderToken(ais, tree, last_param_token, .none); // name
+ try renderIdentifier(ais, tree, last_param_token, .none, .preserve_when_shadowing); // name
last_param_token += 1;
try renderToken(ais, tree, last_param_token, .space); // :
last_param_token += 1;
@@ -1545,7 +1547,7 @@ fn renderSwitchCase(
else
Space.space;
const after_arrow_space: Space = if (switch_case.payload_token == null) pre_target_space else .space;
- try renderToken(ais, tree, switch_case.ast.arrow_token, after_arrow_space);
+ try renderToken(ais, tree, switch_case.ast.arrow_token, after_arrow_space); // =>
if (switch_case.payload_token) |payload_token| {
try renderToken(ais, tree, payload_token - 1, .none); // pipe
@@ -1553,10 +1555,10 @@ fn renderSwitchCase(
if (token_tags[payload_token] == .asterisk) {
try renderToken(ais, tree, payload_token, .none); // asterisk
}
- try renderToken(ais, tree, ident, .none); // identifier
+ try renderIdentifier(ais, tree, ident, .none, .preserve_when_shadowing); // identifier
if (token_tags[ident + 1] == .comma) {
try renderToken(ais, tree, ident + 1, .space); // ,
- try renderToken(ais, tree, ident + 2, .none); // identifier
+ try renderIdentifier(ais, tree, ident + 2, .none, .preserve_when_shadowing); // identifier
try renderToken(ais, tree, ident + 3, pre_target_space); // pipe
} else {
try renderToken(ais, tree, ident + 1, pre_target_space); // pipe
@@ -1581,8 +1583,8 @@ fn renderBlock(
if (token_tags[lbrace - 1] == .colon and
token_tags[lbrace - 2] == .identifier)
{
- try renderToken(ais, tree, lbrace - 2, .none);
- try renderToken(ais, tree, lbrace - 1, .space);
+ try renderIdentifier(ais, tree, lbrace - 2, .none, .eagerly_unquote); // identifier
+ try renderToken(ais, tree, lbrace - 1, .space); // :
}
ais.pushIndentNextLine();
@@ -1635,7 +1637,7 @@ fn renderStructInit(
try renderToken(ais, tree, struct_init.ast.lbrace, .newline);
try renderToken(ais, tree, struct_init.ast.lbrace + 1, .none); // .
- try renderToken(ais, tree, struct_init.ast.lbrace + 2, .space); // name
+ try renderIdentifier(ais, tree, struct_init.ast.lbrace + 2, .space, .eagerly_unquote); // name
try renderToken(ais, tree, struct_init.ast.lbrace + 3, .space); // =
try renderExpression(gpa, ais, tree, struct_init.ast.fields[0], .comma);
@@ -1643,7 +1645,7 @@ fn renderStructInit(
const init_token = tree.firstToken(field_init);
try renderExtraNewlineToken(ais, tree, init_token - 3);
try renderToken(ais, tree, init_token - 3, .none); // .
- try renderToken(ais, tree, init_token - 2, .space); // name
+ try renderIdentifier(ais, tree, init_token - 2, .space, .eagerly_unquote); // name
try renderToken(ais, tree, init_token - 1, .space); // =
try renderExpression(gpa, ais, tree, field_init, .comma);
}
@@ -1656,7 +1658,7 @@ fn renderStructInit(
for (struct_init.ast.fields) |field_init| {
const init_token = tree.firstToken(field_init);
try renderToken(ais, tree, init_token - 3, .none); // .
- try renderToken(ais, tree, init_token - 2, .space); // name
+ try renderIdentifier(ais, tree, init_token - 2, .space, .eagerly_unquote); // name
try renderToken(ais, tree, init_token - 1, .space); // =
try renderExpression(gpa, ais, tree, field_init, .comma_space);
}
@@ -2310,6 +2312,19 @@ fn renderTokenComma(ais: *Ais, tree: Ast, token: Ast.TokenIndex, space: Space) E
}
}
+/// Render an identifier, and the comma that follows it, if it is present in the source.
+/// If a comma is present, and `space` is `Space.comma`, render only a single comma.
+fn renderIdentifierComma(ais: *Ais, tree: Ast, token: Ast.TokenIndex, space: Space, quote: QuoteBehavior) Error!void {
+ const token_tags = tree.tokens.items(.tag);
+ const maybe_comma = token + 1;
+ if (token_tags[maybe_comma] == .comma and space != .comma) {
+ try renderIdentifier(ais, tree, token, .none, quote);
+ return renderToken(ais, tree, maybe_comma, space);
+ } else {
+ return renderIdentifier(ais, tree, token, space, quote);
+ }
+}
+
const Space = enum {
/// Output the token lexeme only.
none,
@@ -2377,6 +2392,158 @@ fn renderSpace(ais: *Ais, tree: Ast, token_index: Ast.TokenIndex, lexeme_len: us
}
}
+const QuoteBehavior = enum {
+ preserve_when_shadowing,
+ eagerly_unquote,
+};
+
+fn renderIdentifier(ais: *Ais, tree: Ast, token_index: Ast.TokenIndex, space: Space, quote: QuoteBehavior) Error!void {
+ const token_tags = tree.tokens.items(.tag);
+ assert(token_tags[token_index] == .identifier);
+ const lexeme = tokenSliceForRender(tree, token_index);
+ if (lexeme[0] != '@') {
+ return renderToken(ais, tree, token_index, space);
+ }
+
+ assert(lexeme.len >= 3);
+ assert(lexeme[0] == '@');
+ assert(lexeme[1] == '\"');
+ assert(lexeme[lexeme.len - 1] == '\"');
+ const contents = lexeme[2 .. lexeme.len - 1]; // inside the @"" quotation
+
+ // Empty name can't be unquoted.
+ if (contents.len == 0) {
+ return renderQuotedIdentifier(ais, tree, token_index, space, false);
+ }
+
+ // Special case for _ which would incorrectly be rejected by isValidId below.
+ if (contents.len == 1 and contents[0] == '_') switch (quote) {
+ .eagerly_unquote => return renderQuotedIdentifier(ais, tree, token_index, space, true),
+ .preserve_when_shadowing => return renderQuotedIdentifier(ais, tree, token_index, space, false),
+ };
+
+ // Scan the entire name for characters that would (after un-escaping) be illegal in a symbol,
+ // i.e. contents don't match: [A-Za-z_][A-Za-z0-9_]*
+ var contents_i: usize = 0;
+ while (contents_i < contents.len) {
+ switch (contents[contents_i]) {
+ '0'...'9' => if (contents_i == 0) return renderQuotedIdentifier(ais, tree, token_index, space, false),
+ 'A'...'Z', 'a'...'z', '_' => {},
+ '\\' => {
+ var esc_offset = contents_i;
+ const res = std.zig.string_literal.parseEscapeSequence(contents, &esc_offset);
+ switch (res) {
+ .success => |char| switch (char) {
+ '0'...'9' => if (contents_i == 0) return renderQuotedIdentifier(ais, tree, token_index, space, false),
+ 'A'...'Z', 'a'...'z', '_' => {},
+ else => return renderQuotedIdentifier(ais, tree, token_index, space, false),
+ },
+ .failure => return renderQuotedIdentifier(ais, tree, token_index, space, false),
+ }
+ contents_i += esc_offset;
+ continue;
+ },
+ else => return renderQuotedIdentifier(ais, tree, token_index, space, false),
+ }
+ contents_i += 1;
+ }
+
+ // Read enough of the name (while un-escaping) to determine if it's a keyword or primitive.
+ // If it's too long to fit in this buffer, we know it's neither and quoting is unnecessary.
+ // If we read the whole thing, we have to do further checks.
+ const longest_keyword_or_primitive_len = comptime blk: {
+ var longest = 0;
+ for (primitives.names.kvs) |kv| {
+ if (kv.key.len > longest) longest = kv.key.len;
+ }
+ for (std.zig.Token.keywords.kvs) |kv| {
+ if (kv.key.len > longest) longest = kv.key.len;
+ }
+ break :blk longest;
+ };
+ var buf: [longest_keyword_or_primitive_len]u8 = undefined;
+
+ contents_i = 0;
+ var buf_i: usize = 0;
+ while (contents_i < contents.len and buf_i < longest_keyword_or_primitive_len) {
+ if (contents[contents_i] == '\\') {
+ const res = std.zig.string_literal.parseEscapeSequence(contents, &contents_i).success;
+ buf[buf_i] = @intCast(u8, res);
+ buf_i += 1;
+ } else {
+ buf[buf_i] = contents[contents_i];
+ contents_i += 1;
+ buf_i += 1;
+ }
+ }
+
+ // We read the whole thing, so it could be a keyword or primitive.
+ if (contents_i == contents.len) {
+ if (!std.zig.isValidId(buf[0..buf_i])) {
+ return renderQuotedIdentifier(ais, tree, token_index, space, false);
+ }
+ if (primitives.isPrimitive(buf[0..buf_i])) switch (quote) {
+ .eagerly_unquote => return renderQuotedIdentifier(ais, tree, token_index, space, true),
+ .preserve_when_shadowing => return renderQuotedIdentifier(ais, tree, token_index, space, false),
+ };
+ }
+
+ try renderQuotedIdentifier(ais, tree, token_index, space, true);
+}
+
+// Renders a @"" quoted identifier, normalizing escapes.
+// Unnecessary escapes are un-escaped, and \u escapes are normalized to \x when they fit.
+// If unquote is true, the @"" is removed and the result is a bare symbol whose validity is asserted.
+fn renderQuotedIdentifier(ais: *Ais, tree: Ast, token_index: Ast.TokenIndex, space: Space, comptime unquote: bool) !void {
+ const token_tags = tree.tokens.items(.tag);
+ assert(token_tags[token_index] == .identifier);
+ const lexeme = tokenSliceForRender(tree, token_index);
+ assert(lexeme.len >= 3 and lexeme[0] == '@');
+
+ if (!unquote) try ais.writer().writeAll("@\"");
+ const contents = lexeme[2 .. lexeme.len - 1];
+ try renderIdentifierContents(ais.writer(), contents);
+ if (!unquote) try ais.writer().writeByte('\"');
+
+ try renderSpace(ais, tree, token_index, lexeme.len, space);
+}
+
+fn renderIdentifierContents(writer: anytype, bytes: []const u8) !void {
+ var pos: usize = 0;
+ while (pos < bytes.len) {
+ const byte = bytes[pos];
+ switch (byte) {
+ '\\' => {
+ const old_pos = pos;
+ const res = std.zig.string_literal.parseEscapeSequence(bytes, &pos);
+ const escape_sequence = bytes[old_pos..pos];
+ switch (res) {
+ .success => |codepoint| {
+ if (codepoint <= 0x7f) {
+ const buf = [1]u8{@intCast(u8, codepoint)};
+ try std.fmt.format(writer, "{}", .{std.zig.fmtEscapes(&buf)});
+ } else {
+ try writer.writeAll(escape_sequence);
+ }
+ },
+ .failure => {
+ try writer.writeAll(escape_sequence);
+ },
+ }
+ },
+ 0x00...('\\' - 1), ('\\' + 1)...0x7f => {
+ const buf = [1]u8{@intCast(u8, byte)};
+ try std.fmt.format(writer, "{}", .{std.zig.fmtEscapes(&buf)});
+ pos += 1;
+ },
+ 0x80...0xff => {
+ try writer.writeByte(byte);
+ pos += 1;
+ },
+ }
+ }
+}
+
/// Returns true if there exists a line comment between any of the tokens from
/// `start_token` to `end_token`. This is used to determine if e.g. a
/// fn_proto should be wrapped and have a trailing comma inserted even if
lib/std/zig/string_literal.zig
@@ -63,7 +63,7 @@ pub fn parseCharLiteral(slice: []const u8) ParsedCharLiteral {
/// Parse an escape sequence from `slice[offset..]`. If parsing is successful,
/// offset is updated to reflect the characters consumed.
-fn parseEscapeSequence(slice: []const u8, offset: *usize) ParsedCharLiteral {
+pub fn parseEscapeSequence(slice: []const u8, offset: *usize) ParsedCharLiteral {
assert(slice.len > offset.*);
assert(slice[offset.*] == '\\');
@@ -274,12 +274,50 @@ pub fn parseAlloc(allocator: std.mem.Allocator, bytes: []const u8) ParseError![]
var buf = std.ArrayList(u8).init(allocator);
defer buf.deinit();
- switch (try parseAppend(&buf, bytes)) {
+ switch (try parseWrite(buf.writer(), bytes)) {
.success => return buf.toOwnedSlice(),
.failure => return error.InvalidLiteral,
}
}
+/// Parses `bytes` as a Zig string literal and writes the result to the std.io.Writer type.
+/// Asserts `bytes` has '"' at beginning and end.
+pub fn parseWrite(writer: anytype, bytes: []const u8) error{OutOfMemory}!Result {
+ assert(bytes.len >= 2 and bytes[0] == '"' and bytes[bytes.len - 1] == '"');
+
+ var index: usize = 1;
+ while (true) {
+ const b = bytes[index];
+
+ switch (b) {
+ '\\' => {
+ const escape_char_index = index + 1;
+ const result = parseEscapeSequence(bytes, &index);
+ switch (result) {
+ .success => |codepoint| {
+ if (bytes[escape_char_index] == 'u') {
+ var buf: [3]u8 = undefined;
+ const len = utf8Encode(codepoint, &buf) catch {
+ return Result{ .failure = .{ .invalid_unicode_codepoint = escape_char_index + 1 } };
+ };
+ try writer.writeAll(buf[0..len]);
+ } else {
+ try writer.writeByte(@intCast(u8, codepoint));
+ }
+ },
+ .failure => |err| return Result{ .failure = err },
+ }
+ },
+ '\n' => return Result{ .failure = .{ .invalid_character = index } },
+ '"' => return Result.success,
+ else => {
+ try writer.writeByte(b);
+ index += 1;
+ },
+ }
+ } else unreachable; // TODO should not need else unreachable on while(true)
+}
+
test "parse" {
const expect = std.testing.expect;
const expectError = std.testing.expectError;
lib/std/zig.zig
@@ -11,6 +11,7 @@ pub const isValidId = fmt.isValidId;
pub const parse = @import("zig/parse.zig").parse;
pub const string_literal = @import("zig/string_literal.zig");
pub const number_literal = @import("zig/number_literal.zig");
+pub const primitives = @import("zig/primitives.zig");
pub const Ast = @import("zig/Ast.zig");
pub const system = @import("zig/system.zig");
pub const CrossTarget = @import("zig/CrossTarget.zig");
src/stage1/astgen.cpp
@@ -3879,6 +3879,27 @@ static Stage1ZirInst *astgen_identifier(Stage1AstGen *ag, Scope *scope, AstNode
}
}
+ {
+ Stage1ZirInst *value = nullptr;
+ if (buf_eql_str(variable_name, "null")) {
+ value = ir_build_const_null(ag, scope, node);
+ } else if (buf_eql_str(variable_name, "true")) {
+ value = ir_build_const_bool(ag, scope, node, true);
+ } else if (buf_eql_str(variable_name, "false")) {
+ value = ir_build_const_bool(ag, scope, node, false);
+ } else if (buf_eql_str(variable_name, "undefined")) {
+ value = ir_build_const_undefined(ag, scope, node);
+ }
+
+ if (value != nullptr) {
+ if (lval == LValPtr || lval == LValAssign) {
+ return ir_build_ref_src(ag, scope, node, value);
+ } else {
+ return ir_expr_wrap(ag, scope, value, result_loc);
+ }
+ }
+ }
+
ZigType *primitive_type;
if ((err = get_primitive_type(ag->codegen, variable_name, &primitive_type))) {
if (err == ErrorOverflow) {
src/stage1/parser.cpp
@@ -1617,11 +1617,7 @@ static AstNode *ast_parse_suffix_expr(ParseContext *pc) {
// / INTEGER
// / KEYWORD_comptime TypeExpr
// / KEYWORD_error DOT IDENTIFIER
-// / KEYWORD_false
-// / KEYWORD_null
// / KEYWORD_promise
-// / KEYWORD_true
-// / KEYWORD_undefined
// / KEYWORD_unreachable
// / STRINGLITERAL
// / SwitchExpr
src/translate_c/ast.zig
@@ -827,7 +827,7 @@ const Context = struct {
}
fn addIdentifier(c: *Context, bytes: []const u8) Allocator.Error!TokenIndex {
- if (@import("../AstGen.zig").isPrimitive(bytes))
+ if (std.zig.primitives.isPrimitive(bytes))
return c.addTokenFmt(.identifier, "@\"{s}\"", .{bytes});
return c.addTokenFmt(.identifier, "{s}", .{std.zig.fmtId(bytes)});
}
src/AstGen.zig
@@ -10,6 +10,8 @@ const ArrayListUnmanaged = std.ArrayListUnmanaged;
const StringIndexAdapter = std.hash_map.StringIndexAdapter;
const StringIndexContext = std.hash_map.StringIndexContext;
+const isPrimitive = std.zig.primitives.isPrimitive;
+
const Zir = @import("Zir.zig");
const refToIndex = Zir.refToIndex;
const indexToRef = Zir.indexToRef;
@@ -4237,33 +4239,7 @@ fn testDecl(
// if not @"" syntax, just use raw token slice
if (ident_name_raw[0] != '@') {
- if (primitives.get(ident_name_raw)) |_| return astgen.failTok(test_name_token, "cannot test a primitive", .{});
-
- if (ident_name_raw.len >= 2) integer: {
- const first_c = ident_name_raw[0];
- if (first_c == 'i' or first_c == 'u') {
- _ = switch (first_c == 'i') {
- true => .signed,
- false => .unsigned,
- };
- if (ident_name_raw.len >= 3 and ident_name_raw[1] == '0') {
- return astgen.failTok(
- test_name_token,
- "primitive integer type '{s}' has leading zero",
- .{ident_name_raw},
- );
- }
- _ = parseBitCount(ident_name_raw[1..]) catch |err| switch (err) {
- error.Overflow => return astgen.failTok(
- test_name_token,
- "primitive integer type '{s}' exceeds maximum bit width of 65535",
- .{ident_name_raw},
- ),
- error.InvalidCharacter => break :integer,
- };
- return astgen.failTok(test_name_token, "cannot test a primitive", .{});
- }
- }
+ if (isPrimitive(ident_name_raw)) return astgen.failTok(test_name_token, "cannot test a primitive", .{});
}
// Local variables, including function parameters.
@@ -7108,7 +7084,7 @@ fn identifier(
// if not @"" syntax, just use raw token slice
if (ident_name_raw[0] != '@') {
- if (primitives.get(ident_name_raw)) |zir_const_ref| {
+ if (primitive_instrs.get(ident_name_raw)) |zir_const_ref| {
return rvalue(gz, ri, zir_const_ref, ident);
}
@@ -8751,7 +8727,7 @@ fn calleeExpr(
}
}
-const primitives = std.ComptimeStringMap(Zir.Inst.Ref, .{
+const primitive_instrs = std.ComptimeStringMap(Zir.Inst.Ref, .{
.{ "anyerror", .anyerror_type },
.{ "anyframe", .anyframe_type },
.{ "anyopaque", .anyopaque_type },
@@ -8795,6 +8771,21 @@ const primitives = std.ComptimeStringMap(Zir.Inst.Ref, .{
.{ "void", .void_type },
});
+comptime {
+ // These checks ensure that std.zig.primitives stays in synce with the primitive->Zir map.
+ const primitives = std.zig.primitives;
+ for (primitive_instrs.kvs) |kv| {
+ if (!primitives.isPrimitive(kv.key)) {
+ @compileError("std.zig.isPrimitive() is not aware of Zir instr '" ++ @tagName(kv.value) ++ "'");
+ }
+ }
+ for (primitives.names.kvs) |kv| {
+ if (primitive_instrs.get(kv.key) == null) {
+ @compileError("std.zig.primitives entry '" ++ kv.key ++ "' does not have a corresponding Zir instr");
+ }
+ }
+}
+
fn nodeMayNeedMemoryLocation(tree: *const Ast, start_node: Ast.Node.Index, have_res_ty: bool) bool {
const node_tags = tree.nodes.items(.tag);
const node_datas = tree.nodes.items(.data);
@@ -9458,7 +9449,7 @@ fn nodeImpliesMoreThanOnePossibleValue(tree: *const Ast, start_node: Ast.Node.In
.identifier => {
const main_tokens = tree.nodes.items(.main_token);
const ident_bytes = tree.tokenSlice(main_tokens[node]);
- if (primitives.get(ident_bytes)) |primitive| switch (primitive) {
+ if (primitive_instrs.get(ident_bytes)) |primitive| switch (primitive) {
.anyerror_type,
.anyframe_type,
.anyopaque_type,
@@ -9702,7 +9693,7 @@ fn nodeImpliesComptimeOnly(tree: *const Ast, start_node: Ast.Node.Index) bool {
.identifier => {
const main_tokens = tree.nodes.items(.main_token);
const ident_bytes = tree.tokenSlice(main_tokens[node]);
- if (primitives.get(ident_bytes)) |primitive| switch (primitive) {
+ if (primitive_instrs.get(ident_bytes)) |primitive| switch (primitive) {
.anyerror_type,
.anyframe_type,
.anyopaque_type,
@@ -12045,19 +12036,6 @@ fn nullTerminatedString(astgen: AstGen, index: usize) [*:0]const u8 {
return @ptrCast([*:0]const u8, astgen.string_bytes.items.ptr) + index;
}
-pub fn isPrimitive(name: []const u8) bool {
- if (primitives.get(name) != null) return true;
- if (name.len < 2) return false;
- const first_c = name[0];
- if (first_c != 'i' and first_c != 'u') return false;
- if (parseBitCount(name[1..])) |_| {
- return true;
- } else |err| switch (err) {
- error.Overflow => return true,
- error.InvalidCharacter => return false,
- }
-}
-
/// Local variables shadowing detection, including function parameters.
fn detectLocalShadowing(
astgen: *AstGen,