authorgravatar for mitchell.hashimoto@gmail.comMitchell Hashimoto <mitchell.hashimoto@gmail.com> 2022-03-22 13:26:35-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-22 19:56:10-04:00
logcb6364624fb28bf51adb2dc16c8e93a30c33c76b
tree41d22ab3ee2d380186d3adfafae2a3c375748cf3
parentb74f2924102fe06addb688dc5fd039dc2756f619

stage2: slice behavior test passes, just has diff behavior from stage1

This is from discussions from #11249. The stage2 behavior is correct and is strictly more accurate, so we'd prefer to keep it. In that case, I modified the behavior tests to have the conditional between stage1/stage2 and get this test passing.

1 files changed, 71 insertions(+), 18 deletions(-)

test/behavior/slice.zig+71-18
......@@ -343,7 +343,10 @@ test "@ptrCast slice to pointer" {
343343}
344344
345345test "slice syntax resulting in pointer-to-array" {
346 if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
346 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
347 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
348 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
349 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
347350
348351 const S = struct {
349352 fn doTheTest() !void {
......@@ -356,8 +359,6 @@ test "slice syntax resulting in pointer-to-array" {
356359 try testPointer0();
357360 try testPointerAlign();
358361 try testSlice();
359 try testSliceZ();
360 try testSlice0();
361362 try testSliceOpt();
362363 try testSliceAlign();
363364 }
......@@ -460,21 +461,6 @@ test "slice syntax resulting in pointer-to-array" {
460461 comptime try expect(@TypeOf(slice.?[0..2]) == *[2]u8);
461462 }
462463
463 fn testSlice0() !void {
464 {
465 var array = [0]u8{};
466 var src_slice: []u8 = &array;
467 var slice = src_slice[0..0];
468 comptime try expect(@TypeOf(slice) == *[0]u8);
469 }
470 {
471 var array = [0:0]u8{};
472 var src_slice: [:0]u8 = &array;
473 var slice = src_slice[0..0];
474 comptime try expect(@TypeOf(slice) == *[0]u8);
475 }
476 }
477
478464 fn testSliceAlign() !void {
479465 var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };
480466 var src_slice: []align(4) u8 = &array;
......@@ -494,6 +480,73 @@ test "slice syntax resulting in pointer-to-array" {
494480 comptime try S.doTheTest();
495481}
496482
483test "slice pointer-to-array null terminated" {
484 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
485 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
486 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
487 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
488
489 comptime {
490 var array = [5:0]u8{ 1, 2, 3, 4, 5 };
491 var slice: [:0]u8 = &array;
492 try expect(@TypeOf(slice[1..3]) == *[2]u8);
493 try expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8);
494
495 if (builtin.zig_backend == .stage1) {
496 try expect(@TypeOf(slice[1..]) == [:0]u8);
497 } else {
498 // stage2 gives a more accurate, correct answer
499 try expect(@TypeOf(slice[1..]) == *[4:0]u8);
500 }
501 }
502
503 var array = [5:0]u8{ 1, 2, 3, 4, 5 };
504 var slice: [:0]u8 = &array;
505 comptime try expect(@TypeOf(slice[1..3]) == *[2]u8);
506 comptime try expect(@TypeOf(slice[1..3 :4]) == *[2:4]u8);
507 comptime try expect(@TypeOf(slice[1..]) == [:0]u8);
508}
509
510test "slice pointer-to-array zero length" {
511 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
512 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
513 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
514 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
515
516 comptime {
517 {
518 var array = [0]u8{};
519 var src_slice: []u8 = &array;
520 var slice = src_slice[0..0];
521 try expect(@TypeOf(slice) == *[0]u8);
522 }
523 {
524 var array = [0:0]u8{};
525 var src_slice: [:0]u8 = &array;
526 var slice = src_slice[0..0];
527 if (builtin.zig_backend == .stage1) {
528 try expect(@TypeOf(slice) == *[0]u8);
529 } else {
530 // stage2 gives a more accurate, correct answer
531 try expect(@TypeOf(slice) == *[0:0]u8);
532 }
533 }
534 }
535
536 {
537 var array = [0]u8{};
538 var src_slice: []u8 = &array;
539 var slice = src_slice[0..0];
540 comptime try expect(@TypeOf(slice) == *[0]u8);
541 }
542 {
543 var array = [0:0]u8{};
544 var src_slice: [:0]u8 = &array;
545 var slice = src_slice[0..0];
546 comptime try expect(@TypeOf(slice) == *[0]u8);
547 }
548}
549
497550test "type coercion of pointer to anon struct literal to pointer to slice" {
498551 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
499552 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO