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