1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
const std = @import("std");
const expect = std.testing.expect;
const builtin = @import("builtin");
test "inline scalar prongs" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: usize = 0;
switch (x) {
10 => |*item| try expect(@TypeOf(item) == *usize),
inline 11 => |*item| {
try expect(@TypeOf(item) == *const usize);
try expect(item.* == 11);
},
else => {},
}
}
test "inline prong ranges" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: usize = 0;
switch (x) {
inline 0...20, 24 => |item| {
if (item > 25) @compileError("bad");
},
else => {},
}
}
const E = enum { a, b, c, d };
test "inline switch enums" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: E = .a;
switch (x) {
inline .a, .b => |aorb| if (aorb != .a and aorb != .b) @compileError("bad"),
inline .c, .d => |cord| if (cord != .c and cord != .d) @compileError("bad"),
}
}
const U = union(E) { a: void, b: u2, c: u3, d: u4 };
test "inline switch unions" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var x: U = .a;
switch (x) {
inline .a, .b => |aorb, tag| {
if (tag == .a) {
try expect(@TypeOf(aorb) == void);
} else {
try expect(tag == .b);
try expect(@TypeOf(aorb) == u2);
}
},
inline .c, .d => |cord, tag| {
if (tag == .c) {
try expect(@TypeOf(cord) == u3);
} else {
try expect(tag == .d);
try expect(@TypeOf(cord) == u4);
}
},
}
}
test "inline else bool" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a = true;
switch (a) {
true => {},
inline else => |val| if (val != false) @compileError("bad"),
}
}
test "inline else error" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Err = error{ a, b, c };
var a = Err.a;
switch (a) {
error.a => {},
inline else => |val| comptime if (val == error.a) @compileError("bad"),
}
}
test "inline else enum" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
const E2 = enum(u8) { a = 2, b = 3, c = 4, d = 5 };
var a: E2 = .a;
switch (a) {
.a, .b => {},
inline else => |val| comptime if (@intFromEnum(val) < 4) @compileError("bad"),
}
}
test "inline else int with gaps" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: u8 = 0;
switch (a) {
1...125, 128...254 => {},
inline else => |val| {
if (val != 0 and
val != 126 and
val != 127 and
val != 255)
@compileError("bad");
},
}
}
test "inline else int all values" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
var a: u2 = 0;
switch (a) {
inline else => |val| {
if (val != 0 and
val != 1 and
val != 2 and
val != 3)
@compileError("bad");
},
}
}
test "inline switch capture is set when switch operand is comptime known" {
const U2 = union(enum) {
a: u32,
};
var u: U2 = undefined;
switch (u) {
inline else => |*f, tag| {
try expect(@TypeOf(f) == *u32);
try expect(tag == .a);
},
}
}
|
