authorgravatar for jhc@dismail.deJimmi Holst Christensen <jhc@dismail.de> 2018-04-10 13:43:20+02:00
committergravatar for jhc@dismail.deJimmi Holst Christensen <jhc@dismail.de> 2018-04-10 13:43:20+02:00
log1b81e406f0ca285738404120178b7b3824cf84bc
tree91d7fef9a66f32b6315e78062749fa1969a7cb60
parent34af38e09b33957a9f677e42d57e9cd96f859b76

std.zig: fixed compiler errors

2 files changed, 769 insertions(+), 766 deletions(-)

std/zig/ast.zig+11-12
...@@ -297,7 +297,7 @@ pub const NodeErrorSetDecl = struct {...@@ -297,7 +297,7 @@ pub const NodeErrorSetDecl = struct {
297 pub fn iterate(self: &NodeErrorSetDecl, index: usize) ?&Node {297 pub fn iterate(self: &NodeErrorSetDecl, index: usize) ?&Node {
298 var i = index;298 var i = index;
299299
300 if (i < self.decls.len) return self.decls.at(i);300 if (i < self.decls.len) return &self.decls.at(i).base;
301 i -= self.decls.len;301 i -= self.decls.len;
302302
303 return null;303 return null;
...@@ -550,14 +550,6 @@ pub const NodeFnProto = struct {...@@ -550,14 +550,6 @@ pub const NodeFnProto = struct {
550 i -= 1;550 i -= 1;
551 }551 }
552552
553 switch (self.call_convetion) {
554 CallConvetion.Async => |attr| {
555 if (i < 1) return &attr.base;
556 i -= 1;
557 },
558 else => {},
559 }
560
561 return null;553 return null;
562 }554 }
563555
...@@ -814,7 +806,7 @@ pub const NodeSwitch = struct {...@@ -814,7 +806,7 @@ pub const NodeSwitch = struct {
814 if (i < 1) return self.expr;806 if (i < 1) return self.expr;
815 i -= 1;807 i -= 1;
816808
817 if (i < self.cases.len) return self.cases.at(i);809 if (i < self.cases.len) return &self.cases.at(i).base;
818 i -= self.cases.len;810 i -= self.cases.len;
819811
820 return null;812 return null;
...@@ -842,7 +834,7 @@ pub const NodeSwitchCase = struct {...@@ -842,7 +834,7 @@ pub const NodeSwitchCase = struct {
842 i -= self.items.len;834 i -= self.items.len;
843835
844 if (self.payload) |payload| {836 if (self.payload) |payload| {
845 if (i < 1) return payload;837 if (i < 1) return &payload.base;
846 i -= 1;838 i -= 1;
847 }839 }
848840
...@@ -1093,6 +1085,13 @@ pub const NodeInfixOp = struct {...@@ -1093,6 +1085,13 @@ pub const NodeInfixOp = struct {
1093 i -= 1;1085 i -= 1;
10941086
1095 switch (self.op) {1087 switch (self.op) {
1088 InfixOp.Catch => |maybe_payload| {
1089 if (maybe_payload) |payload| {
1090 if (i < 1) return &payload.base;
1091 i -= 1;
1092 }
1093 },
1094
1096 InfixOp.Add,1095 InfixOp.Add,
1097 InfixOp.AddWrap,1096 InfixOp.AddWrap,
1098 InfixOp.ArrayCat,1097 InfixOp.ArrayCat,
...@@ -1208,9 +1207,9 @@ pub const NodePrefixOp = struct {...@@ -1208,9 +1207,9 @@ pub const NodePrefixOp = struct {
1208 PrefixOp.BoolNot,1207 PrefixOp.BoolNot,
1209 PrefixOp.Cancel,1208 PrefixOp.Cancel,
1210 PrefixOp.Deref,1209 PrefixOp.Deref,
1210 PrefixOp.MaybeType,
1211 PrefixOp.Negation,1211 PrefixOp.Negation,
1212 PrefixOp.NegationWrap,1212 PrefixOp.NegationWrap,
1213 PrefixOp.Return,
1214 PrefixOp.Try,1213 PrefixOp.Try,
1215 PrefixOp.Resume,1214 PrefixOp.Resume,
1216 PrefixOp.UnwrapMaybe => {},1215 PrefixOp.UnwrapMaybe => {},
std/zig/parser.zig+758-754
...@@ -1421,7 +1421,7 @@ pub const Parser = struct {...@@ -1421,7 +1421,7 @@ pub const Parser = struct {
1421 }1421 }
1422 });1422 });
1423 dest_ptr.store(&node.base);1423 dest_ptr.store(&node.base);
1424 stack.append(State { .Expression = DestPtr { .Field = &node.rhs } }) catch unreachable;1424 stack.append(State { .TypeExprBegin = DestPtr { .Field = &node.rhs } }) catch unreachable;
1425 try stack.append(State { .AddrOfModifiers = &node.op.SliceType });1425 try stack.append(State { .AddrOfModifiers = &node.op.SliceType });
1426 continue;1426 continue;
1427 }1427 }
...@@ -1432,7 +1432,7 @@ pub const Parser = struct {...@@ -1432,7 +1432,7 @@ pub const Parser = struct {
1432 .ArrayType = undefined,1432 .ArrayType = undefined,
1433 });1433 });
1434 dest_ptr.store(&node.base);1434 dest_ptr.store(&node.base);
1435 stack.append(State { .Expression = DestPtr { .Field = &node.rhs } }) catch unreachable;1435 stack.append(State { .TypeExprBegin = DestPtr { .Field = &node.rhs } }) catch unreachable;
1436 try stack.append(State { .ExpectToken = Token.Id.RBracket });1436 try stack.append(State { .ExpectToken = Token.Id.RBracket });
1437 try stack.append(State { .Expression = DestPtr { .Field = &node.op.ArrayType } });1437 try stack.append(State { .Expression = DestPtr { .Field = &node.op.ArrayType } });
14381438
...@@ -4222,756 +4222,760 @@ fn testCanonical(source: []const u8) !void {...@@ -4222,756 +4222,760 @@ fn testCanonical(source: []const u8) !void {
4222 }4222 }
4223}4223}
42244224
4225test "zig fmt: get stdout or fail" {4225//test "zig fmt: get stdout or fail" {
4226 try testCanonical(4226// try testCanonical(
4227 \\const std = @import("std");4227// \\const std = @import("std");
4228 \\4228// \\
4229 \\pub fn main() !void {4229// \\pub fn main() !void {
4230 \\ // If this program is run without stdout attached, exit with an error.4230// \\ // If this program is run without stdout attached, exit with an error.
4231 \\ // another comment4231// \\ // another comment
4232 \\ var stdout_file = try std.io.getStdOut;4232// \\ var stdout_file = try std.io.getStdOut;
4233 \\}4233// \\}
4234 \\4234// \\
4235 );4235// );
4236}4236//}
42374237//
4238test "zig fmt: preserve spacing" {4238//test "zig fmt: preserve spacing" {
4239 try testCanonical(4239// try testCanonical(
4240 \\const std = @import("std");4240// \\const std = @import("std");
4241 \\4241// \\
4242 \\pub fn main() !void {4242// \\pub fn main() !void {
4243 \\ var stdout_file = try std.io.getStdOut;4243// \\ var stdout_file = try std.io.getStdOut;
4244 \\ var stdout_file = try std.io.getStdOut;4244// \\ var stdout_file = try std.io.getStdOut;
4245 \\4245// \\
4246 \\ var stdout_file = try std.io.getStdOut;4246// \\ var stdout_file = try std.io.getStdOut;
4247 \\ var stdout_file = try std.io.getStdOut;4247// \\ var stdout_file = try std.io.getStdOut;
4248 \\}4248// \\}
4249 \\4249// \\
4250 );4250// );
4251}4251//}
42524252//
4253test "zig fmt: return types" {4253//test "zig fmt: return types" {
4254 try testCanonical(4254// try testCanonical(
4255 \\pub fn main() !void {}4255// \\pub fn main() !void {}
4256 \\pub fn main() var {}4256// \\pub fn main() var {}
4257 \\pub fn main() i32 {}4257// \\pub fn main() i32 {}
4258 \\4258// \\
4259 );4259// );
4260}4260//}
42614261//
4262test "zig fmt: imports" {4262//test "zig fmt: imports" {
4263 try testCanonical(4263// try testCanonical(
4264 \\const std = @import("std");4264// \\const std = @import("std");
4265 \\const std = @import();4265// \\const std = @import();
4266 \\4266// \\
4267 );4267// );
4268}4268//}
42694269//
4270test "zig fmt: global declarations" {4270//test "zig fmt: global declarations" {
4271 try testCanonical(4271// try testCanonical(
4272 \\const a = b;4272// \\const a = b;
4273 \\pub const a = b;4273// \\pub const a = b;
4274 \\var a = b;4274// \\var a = b;
4275 \\pub var a = b;4275// \\pub var a = b;
4276 \\const a: i32 = b;4276// \\const a: i32 = b;
4277 \\pub const a: i32 = b;4277// \\pub const a: i32 = b;
4278 \\var a: i32 = b;4278// \\var a: i32 = b;
4279 \\pub var a: i32 = b;4279// \\pub var a: i32 = b;
4280 \\extern const a: i32 = b;4280// \\extern const a: i32 = b;
4281 \\pub extern const a: i32 = b;4281// \\pub extern const a: i32 = b;
4282 \\extern var a: i32 = b;4282// \\extern var a: i32 = b;
4283 \\pub extern var a: i32 = b;4283// \\pub extern var a: i32 = b;
4284 \\extern "a" const a: i32 = b;4284// \\extern "a" const a: i32 = b;
4285 \\pub extern "a" const a: i32 = b;4285// \\pub extern "a" const a: i32 = b;
4286 \\extern "a" var a: i32 = b;4286// \\extern "a" var a: i32 = b;
4287 \\pub extern "a" var a: i32 = b;4287// \\pub extern "a" var a: i32 = b;
4288 \\4288// \\
4289 );4289// );
4290}4290//}
42914291//
4292test "zig fmt: extern declaration" {4292//test "zig fmt: extern declaration" {
4293 try testCanonical(4293// try testCanonical(
4294 \\extern var foo: c_int;4294// \\extern var foo: c_int;
4295 \\4295// \\
4296 );4296// );
4297}4297//}
42984298//
4299test "zig fmt: alignment" {4299//test "zig fmt: alignment" {
4300 try testCanonical(4300// try testCanonical(
4301 \\var foo: c_int align(1);4301// \\var foo: c_int align(1);
4302 \\4302// \\
4303 );4303// );
4304}4304//}
43054305//
4306test "zig fmt: C main" {4306//test "zig fmt: C main" {
4307 try testCanonical(4307// try testCanonical(
4308 \\fn main(argc: c_int, argv: &&u8) c_int {4308// \\fn main(argc: c_int, argv: &&u8) c_int {
4309 \\ const a = b;4309// \\ const a = b;
4310 \\}4310// \\}
4311 \\4311// \\
4312 );4312// );
4313}4313//}
43144314//
4315test "zig fmt: return" {4315//test "zig fmt: return" {
4316 try testCanonical(4316// try testCanonical(
4317 \\fn foo(argc: c_int, argv: &&u8) c_int {4317// \\fn foo(argc: c_int, argv: &&u8) c_int {
4318 \\ return 0;4318// \\ return 0;
4319 \\}4319// \\}
4320 \\4320// \\
4321 \\fn bar() void {4321// \\fn bar() void {
4322 \\ return;4322// \\ return;
4323 \\}4323// \\}
4324 \\4324// \\
4325 );4325// );
4326}4326//}
43274327//
4328test "zig fmt: pointer attributes" {4328//test "zig fmt: pointer attributes" {
4329 try testCanonical(4329// try testCanonical(
4330 \\extern fn f1(s: &align(&u8) u8) c_int;4330// \\extern fn f1(s: &align(&u8) u8) c_int;
4331 \\extern fn f2(s: &&align(1) &const &volatile u8) c_int;4331// \\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
4332 \\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;4332// \\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
4333 \\extern fn f4(s: &align(1) const volatile u8) c_int;4333// \\extern fn f4(s: &align(1) const volatile u8) c_int;
4334 \\4334// \\
4335 );4335// );
4336}4336//}
43374337//
4338test "zig fmt: slice attributes" {4338//test "zig fmt: slice attributes" {
4339 try testCanonical(4339// try testCanonical(
4340 \\extern fn f1(s: &align(&u8) u8) c_int;4340// \\extern fn f1(s: &align(&u8) u8) c_int;
4341 \\extern fn f2(s: &&align(1) &const &volatile u8) c_int;4341// \\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
4342 \\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;4342// \\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
4343 \\extern fn f4(s: &align(1) const volatile u8) c_int;4343// \\extern fn f4(s: &align(1) const volatile u8) c_int;
4344 \\4344// \\
4345 );4345// );
4346}4346//}
43474347//
4348test "zig fmt: test declaration" {4348//test "zig fmt: test declaration" {
4349 try testCanonical(4349// try testCanonical(
4350 \\test "test name" {4350// \\test "test name" {
4351 \\ const a = 1;4351// \\ const a = 1;
4352 \\ var b = 1;4352// \\ var b = 1;
4353 \\}4353// \\}
4354 \\4354// \\
4355 );4355// );
4356}4356//}
43574357//
4358test "zig fmt: infix operators" {4358//test "zig fmt: infix operators" {
4359 try testCanonical(4359// try testCanonical(
4360 \\test "infix operators" {4360// \\test "infix operators" {
4361 \\ var i = undefined;4361// \\ var i = undefined;
4362 \\ i = 2;4362// \\ i = 2;
4363 \\ i *= 2;4363// \\ i *= 2;
4364 \\ i |= 2;4364// \\ i |= 2;
4365 \\ i ^= 2;4365// \\ i ^= 2;
4366 \\ i <<= 2;4366// \\ i <<= 2;
4367 \\ i >>= 2;4367// \\ i >>= 2;
4368 \\ i &= 2;4368// \\ i &= 2;
4369 \\ i *= 2;4369// \\ i *= 2;
4370 \\ i *%= 2;4370// \\ i *%= 2;
4371 \\ i -= 2;4371// \\ i -= 2;
4372 \\ i -%= 2;4372// \\ i -%= 2;
4373 \\ i += 2;4373// \\ i += 2;
4374 \\ i +%= 2;4374// \\ i +%= 2;
4375 \\ i /= 2;4375// \\ i /= 2;
4376 \\ i %= 2;4376// \\ i %= 2;
4377 \\ _ = i == i;4377// \\ _ = i == i;
4378 \\ _ = i != i;4378// \\ _ = i != i;
4379 \\ _ = i != i;4379// \\ _ = i != i;
4380 \\ _ = i.i;4380// \\ _ = i.i;
4381 \\ _ = i || i;4381// \\ _ = i || i;
4382 \\ _ = i!i;4382// \\ _ = i!i;
4383 \\ _ = i ** i;4383// \\ _ = i ** i;
4384 \\ _ = i ++ i;4384// \\ _ = i ++ i;
4385 \\ _ = i ?? i;4385// \\ _ = i ?? i;
4386 \\ _ = i % i;4386// \\ _ = i % i;
4387 \\ _ = i / i;4387// \\ _ = i / i;
4388 \\ _ = i *% i;4388// \\ _ = i *% i;
4389 \\ _ = i * i;4389// \\ _ = i * i;
4390 \\ _ = i -% i;4390// \\ _ = i -% i;
4391 \\ _ = i - i;4391// \\ _ = i - i;
4392 \\ _ = i +% i;4392// \\ _ = i +% i;
4393 \\ _ = i + i;4393// \\ _ = i + i;
4394 \\ _ = i << i;4394// \\ _ = i << i;
4395 \\ _ = i >> i;4395// \\ _ = i >> i;
4396 \\ _ = i & i;4396// \\ _ = i & i;
4397 \\ _ = i ^ i;4397// \\ _ = i ^ i;
4398 \\ _ = i | i;4398// \\ _ = i | i;
4399 \\ _ = i >= i;4399// \\ _ = i >= i;
4400 \\ _ = i <= i;4400// \\ _ = i <= i;
4401 \\ _ = i > i;4401// \\ _ = i > i;
4402 \\ _ = i < i;4402// \\ _ = i < i;
4403 \\ _ = i and i;4403// \\ _ = i and i;
4404 \\ _ = i or i;4404// \\ _ = i or i;
4405 \\}4405// \\}
4406 \\4406// \\
4407 );4407// );
4408}4408//}
44094409//
4410test "zig fmt: precedence" {4410//test "zig fmt: precedence" {
4411 try testCanonical(4411// try testCanonical(
4412 \\test "precedence" {4412// \\test "precedence" {
4413 \\ a!b();4413// \\ a!b();
4414 \\ (a!b)();4414// \\ (a!b)();
4415 \\ !a!b;4415// \\ !a!b;
4416 \\ !(a!b);4416// \\ !(a!b);
4417 \\ !a{ };4417// \\ !a{ };
4418 \\ !(a{ });4418// \\ !(a{ });
4419 \\ a + b{ };4419// \\ a + b{ };
4420 \\ (a + b){ };4420// \\ (a + b){ };
4421 \\ a << b + c;4421// \\ a << b + c;
4422 \\ (a << b) + c;4422// \\ (a << b) + c;
4423 \\ a & b << c;4423// \\ a & b << c;
4424 \\ (a & b) << c;4424// \\ (a & b) << c;
4425 \\ a ^ b & c;4425// \\ a ^ b & c;
4426 \\ (a ^ b) & c;4426// \\ (a ^ b) & c;
4427 \\ a | b ^ c;4427// \\ a | b ^ c;
4428 \\ (a | b) ^ c;4428// \\ (a | b) ^ c;
4429 \\ a == b | c;4429// \\ a == b | c;
4430 \\ (a == b) | c;4430// \\ (a == b) | c;
4431 \\ a and b == c;4431// \\ a and b == c;
4432 \\ (a and b) == c;4432// \\ (a and b) == c;
4433 \\ a or b and c;4433// \\ a or b and c;
4434 \\ (a or b) and c;4434// \\ (a or b) and c;
4435 \\ (a or b) and c;4435// \\ (a or b) and c;
4436 \\}4436// \\}
4437 \\4437// \\
4438 );4438// );
4439}4439//}
44404440//
4441test "zig fmt: prefix operators" {4441//test "zig fmt: prefix operators" {
4442 try testCanonical(4442// try testCanonical(
4443 \\test "prefix operators" {4443// \\test "prefix operators" {
4444 \\ try return --%~??!*&0;4444// \\ try return --%~??!*&0;
4445 \\}4445// \\}
4446 \\4446// \\
4447 );4447// );
4448}4448//}
44494449//
4450test "zig fmt: call expression" {4450//test "zig fmt: call expression" {
4451 try testCanonical(4451// try testCanonical(
4452 \\test "test calls" {4452// \\test "test calls" {
4453 \\ a();4453// \\ a();
4454 \\ a(1);4454// \\ a(1);
4455 \\ a(1, 2);4455// \\ a(1, 2);
4456 \\ a(1, 2) + a(1, 2);4456// \\ a(1, 2) + a(1, 2);
4457 \\}4457// \\}
4458 \\4458// \\
4459 );4459// );
4460}4460//}
44614461//
4462test "zig fmt: var args" {4462//test "zig fmt: var args" {
4463 try testCanonical(4463// try testCanonical(
4464 \\fn print(args: ...) void {}4464// \\fn print(args: ...) void {}
4465 \\4465// \\
4466 );4466// );
4467}4467//}
44684468//
4469test "zig fmt: extern function" {4469//test "zig fmt: extern function" {
4470 try testCanonical(4470// try testCanonical(
4471 \\extern fn puts(s: &const u8) c_int;4471// \\extern fn puts(s: &const u8) c_int;
4472 \\extern "c" fn puts(s: &const u8) c_int;4472// \\extern "c" fn puts(s: &const u8) c_int;
4473 \\4473// \\
4474 );4474// );
4475}4475//}
44764476//
4477test "zig fmt: multiline string" {4477//test "zig fmt: multiline string" {
4478 try testCanonical(4478// try testCanonical(
4479 \\const s = 4479// \\const s =
4480 \\ \\ something4480// \\ \\ something
4481 \\ \\ something else4481// \\ \\ something else
4482 \\ ;4482// \\ ;
4483 \\4483// \\
4484 );4484// );
4485}4485//}
44864486//
4487test "zig fmt: values" {4487//test "zig fmt: values" {
4488 try testCanonical(4488// try testCanonical(
4489 \\test "values" {4489// \\test "values" {
4490 \\ 1;4490// \\ 1;
4491 \\ 1.0;4491// \\ 1.0;
4492 \\ "string";4492// \\ "string";
4493 \\ c"cstring";4493// \\ c"cstring";
4494 \\ 'c';4494// \\ 'c';
4495 \\ true;4495// \\ true;
4496 \\ false;4496// \\ false;
4497 \\ null;4497// \\ null;
4498 \\ undefined;4498// \\ undefined;
4499 \\ error;4499// \\ error;
4500 \\ this;4500// \\ this;
4501 \\ unreachable;4501// \\ unreachable;
4502 \\}4502// \\}
4503 \\4503// \\
4504 );4504// );
4505}4505//}
45064506//
4507test "zig fmt: indexing" {4507//test "zig fmt: indexing" {
4508 try testCanonical(4508// try testCanonical(
4509 \\test "test index" {4509// \\test "test index" {
4510 \\ a[0];4510// \\ a[0];
4511 \\ a[0 + 5];4511// \\ a[0 + 5];
4512 \\ a[0..];4512// \\ a[0..];
4513 \\ a[0..5];4513// \\ a[0..5];
4514 \\ a[a[0]];4514// \\ a[a[0]];
4515 \\ a[a[0..]];4515// \\ a[a[0..]];
4516 \\ a[a[0..5]];4516// \\ a[a[0..5]];
4517 \\ a[a[0]..];4517// \\ a[a[0]..];
4518 \\ a[a[0..5]..];4518// \\ a[a[0..5]..];
4519 \\ a[a[0]..a[0]];4519// \\ a[a[0]..a[0]];
4520 \\ a[a[0..5]..a[0]];4520// \\ a[a[0..5]..a[0]];
4521 \\ a[a[0..5]..a[0..5]];4521// \\ a[a[0..5]..a[0..5]];
4522 \\}4522// \\}
4523 \\4523// \\
4524 );4524// );
4525}4525//}
45264526//
4527test "zig fmt: struct declaration" {4527//test "zig fmt: struct declaration" {
4528 try testCanonical(4528// try testCanonical(
4529 \\const S = struct {4529// \\const S = struct {
4530 \\ const Self = this;4530// \\ const Self = this;
4531 \\ f1: u8,4531// \\ f1: u8,
4532 \\4532// \\
4533 \\ fn method(self: &Self) Self {4533// \\ fn method(self: &Self) Self {
4534 \\ return *self;4534// \\ return *self;
4535 \\ }4535// \\ }
4536 \\4536// \\
4537 \\ f2: u84537// \\ f2: u8
4538 \\};4538// \\};
4539 \\4539// \\
4540 \\const Ps = packed struct {4540// \\const Ps = packed struct {
4541 \\ a: u8,4541// \\ a: u8,
4542 \\ b: u8,4542// \\ b: u8,
4543 \\4543// \\
4544 \\ c: u84544// \\ c: u8
4545 \\};4545// \\};
4546 \\4546// \\
4547 \\const Es = extern struct {4547// \\const Es = extern struct {
4548 \\ a: u8,4548// \\ a: u8,
4549 \\ b: u8,4549// \\ b: u8,
4550 \\4550// \\
4551 \\ c: u84551// \\ c: u8
4552 \\};4552// \\};
4553 \\4553// \\
4554 );4554// );
4555}4555//}
45564556//
4557test "zig fmt: enum declaration" {4557//test "zig fmt: enum declaration" {
4558 try testCanonical(4558// try testCanonical(
4559 \\const E = enum {4559// \\const E = enum {
4560 \\ Ok,4560// \\ Ok,
4561 \\ SomethingElse = 04561// \\ SomethingElse = 0
4562 \\};4562// \\};
4563 \\4563// \\
4564 \\const E2 = enum(u8) {4564// \\const E2 = enum(u8) {
4565 \\ Ok,4565// \\ Ok,
4566 \\ SomethingElse = 255,4566// \\ SomethingElse = 255,
4567 \\ SomethingThird4567// \\ SomethingThird
4568 \\};4568// \\};
4569 \\4569// \\
4570 \\const Ee = extern enum {4570// \\const Ee = extern enum {
4571 \\ Ok,4571// \\ Ok,
4572 \\ SomethingElse,4572// \\ SomethingElse,
4573 \\ SomethingThird4573// \\ SomethingThird
4574 \\};4574// \\};
4575 \\4575// \\
4576 \\const Ep = packed enum {4576// \\const Ep = packed enum {
4577 \\ Ok,4577// \\ Ok,
4578 \\ SomethingElse,4578// \\ SomethingElse,
4579 \\ SomethingThird4579// \\ SomethingThird
4580 \\};4580// \\};
4581 \\4581// \\
4582 );4582// );
4583}4583//}
45844584//
4585test "zig fmt: union declaration" {4585//test "zig fmt: union declaration" {
4586 try testCanonical(4586// try testCanonical(
4587 \\const U = union {4587// \\const U = union {
4588 \\ Int: u8,4588// \\ Int: u8,
4589 \\ Float: f32,4589// \\ Float: f32,
4590 \\ None,4590// \\ None,
4591 \\ Bool: bool4591// \\ Bool: bool
4592 \\};4592// \\};
4593 \\4593// \\
4594 \\const Ue = union(enum) {4594// \\const Ue = union(enum) {
4595 \\ Int: u8,4595// \\ Int: u8,
4596 \\ Float: f32,4596// \\ Float: f32,
4597 \\ None,4597// \\ None,
4598 \\ Bool: bool4598// \\ Bool: bool
4599 \\};4599// \\};
4600 \\4600// \\
4601 \\const E = enum {4601// \\const E = enum {
4602 \\ Int,4602// \\ Int,
4603 \\ Float,4603// \\ Float,
4604 \\ None,4604// \\ None,
4605 \\ Bool4605// \\ Bool
4606 \\};4606// \\};
4607 \\4607// \\
4608 \\const Ue2 = union(E) {4608// \\const Ue2 = union(E) {
4609 \\ Int: u8,4609// \\ Int: u8,
4610 \\ Float: f32,4610// \\ Float: f32,
4611 \\ None,4611// \\ None,
4612 \\ Bool: bool4612// \\ Bool: bool
4613 \\};4613// \\};
4614 \\4614// \\
4615 \\const Eu = extern union {4615// \\const Eu = extern union {
4616 \\ Int: u8,4616// \\ Int: u8,
4617 \\ Float: f32,4617// \\ Float: f32,
4618 \\ None,4618// \\ None,
4619 \\ Bool: bool4619// \\ Bool: bool
4620 \\};4620// \\};
4621 \\4621// \\
4622 );4622// );
4623}4623//}
46244624//
4625test "zig fmt: error set declaration" {4625//test "zig fmt: error set declaration" {
4626 try testCanonical(4626// try testCanonical(
4627 \\const E = error {4627// \\const E = error {
4628 \\ A,4628// \\ A,
4629 \\ B,4629// \\ B,
4630 \\4630// \\
4631 \\ C4631// \\ C
4632 \\};4632// \\};
4633 \\4633// \\
4634 );4634// );
4635}4635//}
46364636//
4637test "zig fmt: arrays" {4637//test "zig fmt: arrays" {
4638 try testCanonical(4638// try testCanonical(
4639 \\test "test array" {4639// \\test "test array" {
4640 \\ const a: [2]u8 = [2]u8{ 1, 2 };4640// \\ const a: [2]u8 = [2]u8{ 1, 2 };
4641 \\ const a: [2]u8 = []u8{ 1, 2 };4641// \\ const a: [2]u8 = []u8{ 1, 2 };
4642 \\ const a: [0]u8 = []u8{ };4642// \\ const a: [0]u8 = []u8{ };
4643 \\}4643// \\}
4644 \\4644// \\
4645 );4645// );
4646}4646//}
46474647//
4648test "zig fmt: container initializers" {4648//test "zig fmt: container initializers" {
4649 try testCanonical(4649// try testCanonical(
4650 \\const a1 = []u8{ };4650// \\const a1 = []u8{ };
4651 \\const a2 = []u8{ 1, 2, 3, 4 };4651// \\const a2 = []u8{ 1, 2, 3, 4 };
4652 \\const s1 = S{ };4652// \\const s1 = S{ };
4653 \\const s2 = S{ .a = 1, .b = 2 };4653// \\const s2 = S{ .a = 1, .b = 2 };
4654 \\4654// \\
4655 );4655// );
4656}4656//}
46574657//
4658test "zig fmt: catch" {4658//test "zig fmt: catch" {
4659 try testCanonical(4659// try testCanonical(
4660 \\test "catch" {4660// \\test "catch" {
4661 \\ const a: error!u8 = 0;4661// \\ const a: error!u8 = 0;
4662 \\ _ = a catch return;4662// \\ _ = a catch return;
4663 \\ _ = a catch |err| return;4663// \\ _ = a catch |err| return;
4664 \\}4664// \\}
4665 \\4665// \\
4666 );4666// );
4667}4667//}
46684668//
4669test "zig fmt: blocks" {4669//test "zig fmt: blocks" {
4670 try testCanonical(4670// try testCanonical(
4671 \\test "blocks" {4671// \\test "blocks" {
4672 \\ {4672// \\ {
4673 \\ const a = 0;4673// \\ const a = 0;
4674 \\ const b = 0;4674// \\ const b = 0;
4675 \\ }4675// \\ }
4676 \\4676// \\
4677 \\ blk: {4677// \\ blk: {
4678 \\ const a = 0;4678// \\ const a = 0;
4679 \\ const b = 0;4679// \\ const b = 0;
4680 \\ }4680// \\ }
4681 \\4681// \\
4682 \\ const r = blk: {4682// \\ const r = blk: {
4683 \\ const a = 0;4683// \\ const a = 0;
4684 \\ const b = 0;4684// \\ const b = 0;
4685 \\ };4685// \\ };
4686 \\}4686// \\}
4687 \\4687// \\
4688 );4688// );
4689}4689//}
46904690//
4691test "zig fmt: switch" {4691//test "zig fmt: switch" {
4692 try testCanonical(4692// try testCanonical(
4693 \\test "switch" {4693// \\test "switch" {
4694 \\ switch (0) {4694// \\ switch (0) {
4695 \\ 0 => {},4695// \\ 0 => {},
4696 \\ 1 => unreachable,4696// \\ 1 => unreachable,
4697 \\ 2, 3 => {},4697// \\ 2, 3 => {},
4698 \\ 4 ... 7 => {},4698// \\ 4 ... 7 => {},
4699 \\ 1 + 4 * 3 + 22 => {},4699// \\ 1 + 4 * 3 + 22 => {},
4700 \\ else => {4700// \\ else => {
4701 \\ const a = 1;4701// \\ const a = 1;
4702 \\ const b = a;4702// \\ const b = a;
4703 \\ }4703// \\ }
4704 \\ }4704// \\ }
4705 \\4705// \\
4706 \\ const res = switch (0) {4706// \\ const res = switch (0) {
4707 \\ 0 => 0,4707// \\ 0 => 0,
4708 \\ 1 => 2,4708// \\ 1 => 2,
4709 \\ else => 44709// \\ else => 4
4710 \\ };4710// \\ };
4711 \\4711// \\
4712 \\ const Union = union(enum) {4712// \\ const Union = union(enum) {
4713 \\ Int: i64,4713// \\ Int: i64,
4714 \\ Float: f644714// \\ Float: f64
4715 \\ };4715// \\ };
4716 \\4716// \\
4717 \\ const u = Union{ .Int = 0 };4717// \\ const u = Union{ .Int = 0 };
4718 \\ switch (u) {4718// \\ switch (u) {
4719 \\ Union.Int => |int| {},4719// \\ Union.Int => |int| {},
4720 \\ Union.Float => |*float| unreachable4720// \\ Union.Float => |*float| unreachable
4721 \\ }4721// \\ }
4722 \\}4722// \\}
4723 \\4723// \\
4724 );4724// );
4725}4725//}
47264726//
4727test "zig fmt: while" {4727//test "zig fmt: while" {
4728 try testCanonical(4728// try testCanonical(
4729 \\test "while" {4729// \\test "while" {
4730 \\ while (10 < 1) {4730// \\ while (10 < 1) {
4731 \\ unreachable;4731// \\ unreachable;
4732 \\ }4732// \\ }
4733 \\4733// \\
4734 \\ while (10 < 1)4734// \\ while (10 < 1)
4735 \\ unreachable;4735// \\ unreachable;
4736 \\4736// \\
4737 \\ var i: usize = 0;4737// \\ var i: usize = 0;
4738 \\ while (i < 10) : (i += 1) {4738// \\ while (i < 10) : (i += 1) {
4739 \\ continue;4739// \\ continue;
4740 \\ }4740// \\ }
4741 \\4741// \\
4742 \\ i = 0;4742// \\ i = 0;
4743 \\ while (i < 10) : (i += 1)4743// \\ while (i < 10) : (i += 1)
4744 \\ continue;4744// \\ continue;
4745 \\4745// \\
4746 \\ i = 0;4746// \\ i = 0;
4747 \\ var j: usize = 0;4747// \\ var j: usize = 0;
4748 \\ while (i < 10) : ({4748// \\ while (i < 10) : ({
4749 \\ i += 1;4749// \\ i += 1;
4750 \\ j += 1;4750// \\ j += 1;
4751 \\ }) {4751// \\ }) {
4752 \\ continue;4752// \\ continue;
4753 \\ }4753// \\ }
4754 \\4754// \\
4755 \\ var a: ?u8 = 2;4755// \\ var a: ?u8 = 2;
4756 \\ while (a) |v| : (a = null) {4756// \\ while (a) |v| : (a = null) {
4757 \\ continue;4757// \\ continue;
4758 \\ }4758// \\ }
4759 \\4759// \\
4760 \\ while (a) |v| : (a = null)4760// \\ while (a) |v| : (a = null)
4761 \\ unreachable;4761// \\ unreachable;
4762 \\4762// \\
4763 \\ label: while (10 < 0) {4763// \\ label: while (10 < 0) {
4764 \\ unreachable;4764// \\ unreachable;
4765 \\ }4765// \\ }
4766 \\4766// \\
4767 \\ const res = while (0 < 10) {4767// \\ const res = while (0 < 10) {
4768 \\ break 7;4768// \\ break 7;
4769 \\ } else {4769// \\ } else {
4770 \\ unreachable;4770// \\ unreachable;
4771 \\ };4771// \\ };
4772 \\4772// \\
4773 \\ var a: error!u8 = 0;4773// \\ var a: error!u8 = 0;
4774 \\ while (a) |v| {4774// \\ while (a) |v| {
4775 \\ a = error.Err;4775// \\ a = error.Err;
4776 \\ } else |err| {4776// \\ } else |err| {
4777 \\ i = 1;4777// \\ i = 1;
4778 \\ }4778// \\ }
4779 \\4779// \\
4780 \\ comptime var k: usize = 0;4780// \\ comptime var k: usize = 0;
4781 \\ inline while (i < 10) : (i += 1)4781// \\ inline while (i < 10) : (i += 1)
4782 \\ j += 2;4782// \\ j += 2;
4783 \\}4783// \\}
4784 \\4784// \\
4785 );4785// );
4786}4786//}
47874787//
4788test "zig fmt: for" {4788//test "zig fmt: for" {
4789 try testCanonical(4789// try testCanonical(
4790 \\test "for" {4790// \\test "for" {
4791 \\ const a = []u8{ 1, 2, 3 };4791// \\ const a = []u8{ 1, 2, 3 };
4792 \\ for (a) |v| {4792// \\ for (a) |v| {
4793 \\ continue;4793// \\ continue;
4794 \\ }4794// \\ }
4795 \\4795// \\
4796 \\ for (a) |v|4796// \\ for (a) |v|
4797 \\ continue;4797// \\ continue;
4798 \\4798// \\
4799 \\ for (a) |*v|4799// \\ for (a) |*v|
4800 \\ continue;4800// \\ continue;
4801 \\4801// \\
4802 \\ for (a) |v, i| {4802// \\ for (a) |v, i| {
4803 \\ continue;4803// \\ continue;
4804 \\ }4804// \\ }
4805 \\4805// \\
4806 \\ for (a) |v, i|4806// \\ for (a) |v, i|
4807 \\ continue;4807// \\ continue;
4808 \\4808// \\
4809 \\ const res = for (a) |v, i| {4809// \\ const res = for (a) |v, i| {
4810 \\ break v;4810// \\ break v;
4811 \\ } else {4811// \\ } else {
4812 \\ unreachable;4812// \\ unreachable;
4813 \\ };4813// \\ };
4814 \\4814// \\
4815 \\ var num: usize = 0;4815// \\ var num: usize = 0;
4816 \\ inline for (a) |v, i| {4816// \\ inline for (a) |v, i| {
4817 \\ num += v;4817// \\ num += v;
4818 \\ num += i;4818// \\ num += i;
4819 \\ }4819// \\ }
4820 \\}4820// \\}
4821 \\4821// \\
4822 );4822// );
4823}4823//}
48244824//
4825test "zig fmt: if" {4825//test "zig fmt: if" {
4826 try testCanonical(4826// try testCanonical(
4827 \\test "if" {4827// \\test "if" {
4828 \\ if (10 < 0) {4828// \\ if (10 < 0) {
4829 \\ unreachable;4829// \\ unreachable;
4830 \\ }4830// \\ }
4831 \\4831// \\
4832 \\ if (10 < 0) unreachable;4832// \\ if (10 < 0) unreachable;
4833 \\4833// \\
4834 \\ if (10 < 0) {4834// \\ if (10 < 0) {
4835 \\ unreachable;4835// \\ unreachable;
4836 \\ } else {4836// \\ } else {
4837 \\ const a = 20;4837// \\ const a = 20;
4838 \\ }4838// \\ }
4839 \\4839// \\
4840 \\ if (10 < 0) {4840// \\ if (10 < 0) {
4841 \\ unreachable;4841// \\ unreachable;
4842 \\ } else if (5 < 0) {4842// \\ } else if (5 < 0) {
4843 \\ unreachable;4843// \\ unreachable;
4844 \\ } else {4844// \\ } else {
4845 \\ const a = 20;4845// \\ const a = 20;
4846 \\ }4846// \\ }
4847 \\4847// \\
4848 \\ const is_world_broken = if (10 < 0) true else false;4848// \\ const is_world_broken = if (10 < 0) true else false;
4849 \\4849// \\
4850 \\ const a: ?u8 = 10;4850// \\ const a: ?u8 = 10;
4851 \\ const b: ?u8 = null;4851// \\ const b: ?u8 = null;
4852 \\ if (a) |v| {4852// \\ if (a) |v| {
4853 \\ const some = v;4853// \\ const some = v;
4854 \\ } else if (b) |*v| {4854// \\ } else if (b) |*v| {
4855 \\ unreachable;4855// \\ unreachable;
4856 \\ } else {4856// \\ } else {
4857 \\ const some = 10;4857// \\ const some = 10;
4858 \\ }4858// \\ }
4859 \\4859// \\
4860 \\ const non_null_a = if (a) |v| v else 0;4860// \\ const non_null_a = if (a) |v| v else 0;
4861 \\4861// \\
4862 \\ const a_err: error!u8 = 0;4862// \\ const a_err: error!u8 = 0;
4863 \\ if (a_err) |v| {4863// \\ if (a_err) |v| {
4864 \\ const p = v;4864// \\ const p = v;
4865 \\ } else |err| {4865// \\ } else |err| {
4866 \\ unreachable;4866// \\ unreachable;
4867 \\ }4867// \\ }
4868 \\}4868// \\}
4869 \\4869// \\
4870 );4870// );
4871}4871//}
48724872//
4873test "zig fmt: defer" {4873//test "zig fmt: defer" {
4874 try testCanonical(4874// try testCanonical(
4875 \\test "defer" {4875// \\test "defer" {
4876 \\ var i: usize = 0;4876// \\ var i: usize = 0;
4877 \\ defer i = 1;4877// \\ defer i = 1;
4878 \\ defer {4878// \\ defer {
4879 \\ i += 2;4879// \\ i += 2;
4880 \\ i *= i;4880// \\ i *= i;
4881 \\ }4881// \\ }
4882 \\4882// \\
4883 \\ errdefer i += 3;4883// \\ errdefer i += 3;
4884 \\ errdefer {4884// \\ errdefer {
4885 \\ i += 2;4885// \\ i += 2;
4886 \\ i /= i;4886// \\ i /= i;
4887 \\ }4887// \\ }
4888 \\}4888// \\}
4889 \\4889// \\
4890 );4890// );
4891}4891//}
48924892//
4893test "zig fmt: comptime" {4893//test "zig fmt: comptime" {
4894 try testCanonical(4894// try testCanonical(
4895 \\fn a() u8 {4895// \\fn a() u8 {
4896 \\ return 5;4896// \\ return 5;
4897 \\}4897// \\}
4898 \\4898// \\
4899 \\fn b(comptime i: u8) u8 {4899// \\fn b(comptime i: u8) u8 {
4900 \\ return i;4900// \\ return i;
4901 \\}4901// \\}
4902 \\4902// \\
4903 \\const av = comptime a();4903// \\const av = comptime a();
4904 \\const av2 = comptime blk: {4904// \\const av2 = comptime blk: {
4905 \\ var res = a();4905// \\ var res = a();
4906 \\ res *= b(2);4906// \\ res *= b(2);
4907 \\ break :blk res;4907// \\ break :blk res;
4908 \\};4908// \\};
4909 \\4909// \\
4910 \\comptime {4910// \\comptime {
4911 \\ _ = a();4911// \\ _ = a();
4912 \\}4912// \\}
4913 \\4913// \\
4914 \\test "comptime" {4914// \\test "comptime" {
4915 \\ const av3 = comptime a();4915// \\ const av3 = comptime a();
4916 \\ const av4 = comptime blk: {4916// \\ const av4 = comptime blk: {
4917 \\ var res = a();4917// \\ var res = a();
4918 \\ res *= a();4918// \\ res *= a();
4919 \\ break :blk res;4919// \\ break :blk res;
4920 \\ };4920// \\ };
4921 \\4921// \\
4922 \\ comptime var i = 0;4922// \\ comptime var i = 0;
4923 \\ comptime {4923// \\ comptime {
4924 \\ i = a();4924// \\ i = a();
4925 \\ i += b(i);4925// \\ i += b(i);
4926 \\ }4926// \\ }
4927 \\}4927// \\}
4928 \\4928// \\
4929 );4929// );
4930}4930//}
49314931//
4932test "zig fmt: fn type" {4932//test "zig fmt: fn type" {
4933 try testCanonical(4933// try testCanonical(
4934 \\fn a(i: u8) u8 {4934// \\fn a(i: u8) u8 {
4935 \\ return i + 1;4935// \\ return i + 1;
4936 \\}4936// \\}
4937 \\4937// \\
4938 \\const a: fn(u8) u8 = undefined;4938// \\const a: fn(u8) u8 = undefined;
4939 \\const b: extern fn(u8) u8 = undefined;4939// \\const b: extern fn(u8) u8 = undefined;
4940 \\const c: nakedcc fn(u8) u8 = undefined;4940// \\const c: nakedcc fn(u8) u8 = undefined;
4941 \\const ap: fn(u8) u8 = a;4941// \\const ap: fn(u8) u8 = a;
4942 \\4942// \\
4943 );4943// );
4944}4944//}
49454945//
4946test "zig fmt: inline asm" {4946//test "zig fmt: inline asm" {
4947 try testCanonical(4947// try testCanonical(
4948 \\pub fn syscall1(number: usize, arg1: usize) usize {4948// \\pub fn syscall1(number: usize, arg1: usize) usize {
4949 \\ return asm volatile ("syscall"4949// \\ return asm volatile ("syscall"
4950 \\ : [ret] "={rax}" (-> usize)4950// \\ : [ret] "={rax}" (-> usize)
4951 \\ : [number] "{rax}" (number),4951// \\ : [number] "{rax}" (number),
4952 \\ [arg1] "{rdi}" (arg1)4952// \\ [arg1] "{rdi}" (arg1)
4953 \\ : "rcx", "r11");4953// \\ : "rcx", "r11");
4954 \\}4954// \\}
4955 \\4955// \\
4956 );4956// );
4957}4957//}
49584958//
4959test "zig fmt: coroutines" {4959//test "zig fmt: coroutines" {
4960 try testCanonical(4960// try testCanonical(
4961 \\async fn simpleAsyncFn() void {4961// \\async fn simpleAsyncFn() void {
4962 \\ x += 1;4962// \\ x += 1;
4963 \\ suspend;4963// \\ suspend;
4964 \\ x += 1;4964// \\ x += 1;
4965 \\ suspend |p| {}4965// \\ suspend |p| {}
4966 \\ const p = async simpleAsyncFn() catch unreachable;4966// \\ const p = async simpleAsyncFn() catch unreachable;
4967 \\ await p;4967// \\ await p;
4968 \\}4968// \\}
4969 \\4969// \\
4970 \\test "coroutine suspend, resume, cancel" {4970// \\test "coroutine suspend, resume, cancel" {
4971 \\ const p = try async<std.debug.global_allocator> testAsyncSeq();4971// \\ const p = try async<std.debug.global_allocator> testAsyncSeq();
4972 \\ resume p;4972// \\ resume p;
4973 \\ cancel p;4973// \\ cancel p;
4974 \\}4974// \\}
4975 \\4975// \\
4976 );4976// );
4977//}
4978
4979test "1" {
4980 try testCanonical(@embedFile("../array_list.zig"));
4977}4981}