lang: Add u64 and i64 types

db9373cdbb409294c35ac0e51f6661d4c264061aff00f950318699692c8cbb8b
Add the 64-bit integer types to the scanner, parser, resolver and
lowering, with 64-bit arithmetic, shifts, comparisons and casts.

Integer literals stay 32-bit immediates that are sign-extended when
widened, so a literal of a 64-bit type must fit in 31 bits (u64) or in
the i32 range (i64). Wider values are built with shifts at run time.

Assisted-by: Claude:opus-5.5
Alexis Sellier committed ago 1 parent a2300ff4
lib/std/arch/rv64/tests/arith.w64.rad added +255 -0
1 +
//! Test 64-bit integer arithmetic.
2 +
//! Verifies that i64/u64 operations use full-width instructions
3 +
//! and that widening/narrowing casts work correctly.
4 +
5 +
fn testI64Add() -> bool {
6 +
    let a: i64 = 100;
7 +
    let b: i64 = 200;
8 +
    let result: i64 = a + b;
9 +
    if result != 300 {
10 +
        return false;
11 +
    }
12 +
    return true;
13 +
}
14 +
15 +
fn testU64Add() -> bool {
16 +
    let a: u64 = 100;
17 +
    let b: u64 = 200;
18 +
    let result: u64 = a + b;
19 +
    if result != 300 {
20 +
        return false;
21 +
    }
22 +
    return true;
23 +
}
24 +
25 +
fn testI64Sub() -> bool {
26 +
    let a: i64 = 500;
27 +
    let b: i64 = 300;
28 +
    let result: i64 = a - b;
29 +
    if result != 200 {
30 +
        return false;
31 +
    }
32 +
    return true;
33 +
}
34 +
35 +
fn testI64Mul() -> bool {
36 +
    let a: i64 = 1000;
37 +
    let b: i64 = 2000;
38 +
    let result: i64 = a * b;
39 +
    if result != 2000000 {
40 +
        return false;
41 +
    }
42 +
    return true;
43 +
}
44 +
45 +
fn testI64Div() -> bool {
46 +
    let a: i64 = 1000;
47 +
    let b: i64 = 10;
48 +
    let result: i64 = a / b;
49 +
    if result != 100 {
50 +
        return false;
51 +
    }
52 +
    return true;
53 +
}
54 +
55 +
fn testU64Div() -> bool {
56 +
    let a: u64 = 1000;
57 +
    let b: u64 = 10;
58 +
    let result: u64 = a / b;
59 +
    if result != 100 {
60 +
        return false;
61 +
    }
62 +
    return true;
63 +
}
64 +
65 +
fn testI64Neg() -> bool {
66 +
    let a: i64 = 42;
67 +
    let result: i64 = -a;
68 +
    if result != -42 {
69 +
        return false;
70 +
    }
71 +
    return true;
72 +
}
73 +
74 +
fn testI64Shift() -> bool {
75 +
    let a: i64 = 1;
76 +
    let result: i64 = a << 40;
77 +
    if (result >> 20) != 1048576 {
78 +
        return false;
79 +
    }
80 +
    let back: i64 = result >> 40;
81 +
    if back != 1 {
82 +
        return false;
83 +
    }
84 +
    return true;
85 +
}
86 +
87 +
fn testU64Shift() -> bool {
88 +
    let a: u64 = 1;
89 +
    let shifted: u64 = a << 32;
90 +
    // Shift by 32 should NOT wrap like u32 would.
91 +
    let back: u64 = shifted >> 32;
92 +
    if back != 1 {
93 +
        return false;
94 +
    }
95 +
    return true;
96 +
}
97 +
98 +
fn testI64Bitwise() -> bool {
99 +
    let a: i64 = 0xFF00;
100 +
    let b: i64 = 0x0FF0;
101 +
    let andResult: i64 = a & b;
102 +
    if andResult != 0x0F00 {
103 +
        return false;
104 +
    }
105 +
    let orResult: i64 = a | b;
106 +
    if orResult != 0xFFF0 {
107 +
        return false;
108 +
    }
109 +
    let xorResult: i64 = a ^ b;
110 +
    if xorResult != 0xF0F0 {
111 +
        return false;
112 +
    }
113 +
    return true;
114 +
}
115 +
116 +
fn testWidenI32ToI64() -> bool {
117 +
    let a: i32 = -42;
118 +
    let b: i64 = a as i64;
119 +
    if b != -42 {
120 +
        return false;
121 +
    }
122 +
    return true;
123 +
}
124 +
125 +
fn testWidenU32ToU64() -> bool {
126 +
    let a: u32 = 0xFFFFFFFF;
127 +
    let b: u64 = a as u64;
128 +
    // Should zero-extend, not sign-extend.
129 +
    // If sign-extended, this would be a very large negative number in i64.
130 +
    let c: u64 = b >> 32;
131 +
    if c != 0 {
132 +
        return false;
133 +
    }
134 +
    return true;
135 +
}
136 +
137 +
fn testNarrowI64ToI32() -> bool {
138 +
    let a: i64 = 42;
139 +
    let b: i32 = a as i32;
140 +
    if b != 42 {
141 +
        return false;
142 +
    }
143 +
    return true;
144 +
}
145 +
146 +
fn testNarrowU64ToU32() -> bool {
147 +
    let a: u64 = 42;
148 +
    let b: u32 = a as u32;
149 +
    if b != 42 {
150 +
        return false;
151 +
    }
152 +
    return true;
153 +
}
154 +
155 +
fn testI64Compare() -> bool {
156 +
    let a: i64 = -1;
157 +
    let b: i64 = 1;
158 +
    if a >= b {
159 +
        return false;
160 +
    }
161 +
    if b <= a {
162 +
        return false;
163 +
    }
164 +
    return true;
165 +
}
166 +
167 +
fn testU64Compare() -> bool {
168 +
    let a: u64 = 100;
169 +
    let b: u64 = 200;
170 +
    if a >= b {
171 +
        return false;
172 +
    }
173 +
    if b <= a {
174 +
        return false;
175 +
    }
176 +
    return true;
177 +
}
178 +
179 +
fn testI64Modulo() -> bool {
180 +
    let a: i64 = 17;
181 +
    let b: i64 = 5;
182 +
    let result: i64 = a % b;
183 +
    if result != 2 {
184 +
        return false;
185 +
    }
186 +
    return true;
187 +
}
188 +
189 +
fn testU64Modulo() -> bool {
190 +
    let a: u64 = 17;
191 +
    let b: u64 = 5;
192 +
    let result: u64 = a % b;
193 +
    if result != 2 {
194 +
        return false;
195 +
    }
196 +
    return true;
197 +
}
198 +
199 +
@default fn main() -> i32 {
200 +
    if not testI64Add() {
201 +
        return 1;
202 +
    }
203 +
    if not testU64Add() {
204 +
        return 2;
205 +
    }
206 +
    if not testI64Sub() {
207 +
        return 3;
208 +
    }
209 +
    if not testI64Mul() {
210 +
        return 4;
211 +
    }
212 +
    if not testI64Div() {
213 +
        return 5;
214 +
    }
215 +
    if not testU64Div() {
216 +
        return 6;
217 +
    }
218 +
    if not testI64Neg() {
219 +
        return 7;
220 +
    }
221 +
    if not testI64Shift() {
222 +
        return 8;
223 +
    }
224 +
    if not testU64Shift() {
225 +
        return 9;
226 +
    }
227 +
    if not testI64Bitwise() {
228 +
        return 10;
229 +
    }
230 +
    if not testWidenI32ToI64() {
231 +
        return 11;
232 +
    }
233 +
    if not testWidenU32ToU64() {
234 +
        return 12;
235 +
    }
236 +
    if not testNarrowI64ToI32() {
237 +
        return 13;
238 +
    }
239 +
    if not testNarrowU64ToU32() {
240 +
        return 14;
241 +
    }
242 +
    if not testI64Compare() {
243 +
        return 15;
244 +
    }
245 +
    if not testU64Compare() {
246 +
        return 16;
247 +
    }
248 +
    if not testI64Modulo() {
249 +
        return 17;
250 +
    }
251 +
    if not testU64Modulo() {
252 +
        return 18;
253 +
    }
254 +
    return 0;
255 +
}
lib/std/lang/lower.rad +4 -2
5505 5505
}
5506 5506
5507 5507
/// Check whether a resolver type is a signed integer type.
5508 5508
fn isSignedType(t: resolver::Type) -> bool {
5509 5509
    match t {
5510 -
        case resolver::Type::I8, resolver::Type::I16, resolver::Type::I32 => return true,
5510 +
        case resolver::Type::I8, resolver::Type::I16, resolver::Type::I32, resolver::Type::I64 => return true,
5511 5511
        else => return false,
5512 5512
    }
5513 5513
}
5514 5514
5515 5515
/// Check whether a resolver type is an unsigned integer type.
5516 5516
fn isUnsignedType(t: resolver::Type) -> bool {
5517 5517
    match t {
5518 -
        case resolver::Type::U8, resolver::Type::U16, resolver::Type::U32 => return true,
5518 +
        case resolver::Type::U8, resolver::Type::U16, resolver::Type::U32, resolver::Type::U64 => return true,
5519 5519
        else => return false,
5520 5520
    }
5521 5521
}
5522 5522
5523 5523
/// Lower a string literal to a slice value.
6192 6192
        case resolver::Type::I16 => return il::Type::W16,
6193 6193
        case resolver::Type::I32 => return il::Type::W32,
6194 6194
        case resolver::Type::U8 => return il::Type::W8,
6195 6195
        case resolver::Type::U16 => return il::Type::W16,
6196 6196
        case resolver::Type::U32 => return il::Type::W32,
6197 +
        case resolver::Type::I64 => return il::Type::W64,
6198 +
        case resolver::Type::U64 => return il::Type::W64,
6197 6199
        // Reference types are all pointer-sized (64-bit on RV64).
6198 6200
        case resolver::Type::Pointer { .. } => return il::Type::W64,
6199 6201
        // Aggregates are represented as pointers to stack memory.
6200 6202
        case resolver::Type::Slice { .. } => return il::Type::W64,
6201 6203
        case resolver::Type::Array(_) => return il::Type::W64,
lib/std/lang/lower/tests/arith.w64.rad added +69 -0
1 +
/// Add two i64 values.
2 +
fn addI64(a: i64, b: i64) -> i64 {
3 +
    return a + b;
4 +
}
5 +
6 +
/// Subtract two i64 values.
7 +
fn subI64(a: i64, b: i64) -> i64 {
8 +
    return a - b;
9 +
}
10 +
11 +
/// Multiply two i64 values.
12 +
fn mulI64(a: i64, b: i64) -> i64 {
13 +
    return a * b;
14 +
}
15 +
16 +
/// Add two u64 values.
17 +
fn addU64(a: u64, b: u64) -> u64 {
18 +
    return a + b;
19 +
}
20 +
21 +
/// Subtract two u64 values.
22 +
fn subU64(a: u64, b: u64) -> u64 {
23 +
    return a - b;
24 +
}
25 +
26 +
/// Multiply two u64 values.
27 +
fn mulU64(a: u64, b: u64) -> u64 {
28 +
    return a * b;
29 +
}
30 +
31 +
/// Left-shift u64.
32 +
fn shlU64(a: u64, b: u64) -> u64 {
33 +
    return a << b;
34 +
}
35 +
36 +
/// Right-shift i64 (arithmetic).
37 +
fn shrI64(a: i64, b: i64) -> i64 {
38 +
    return a >> b;
39 +
}
40 +
41 +
/// Divide i64 values.
42 +
fn divI64(a: i64, b: i64) -> i64 {
43 +
    return a / b;
44 +
}
45 +
46 +
/// Divide u64 values.
47 +
fn divU64(a: u64, b: u64) -> u64 {
48 +
    return a / b;
49 +
}
50 +
51 +
/// Widen i32 to i64.
52 +
fn widenI32ToI64(a: i32) -> i64 {
53 +
    return a as i64;
54 +
}
55 +
56 +
/// Widen u32 to u64.
57 +
fn widenU32ToU64(a: u32) -> u64 {
58 +
    return a as u64;
59 +
}
60 +
61 +
/// Narrow i64 to i32.
62 +
fn narrowI64ToI32(a: i64) -> i32 {
63 +
    return a as i32;
64 +
}
65 +
66 +
/// Narrow u64 to u32.
67 +
fn narrowU64ToU32(a: u64) -> u32 {
68 +
    return a as u32;
69 +
}
lib/std/lang/lower/tests/arith.w64.ril added +83 -0
1 +
fn w64 $addI64(w64 %0, w64 %1) {
2 +
  @entry0
3 +
    add w64 %2 %0 %1;
4 +
    ret %2;
5 +
}
6 +
7 +
fn w64 $subI64(w64 %0, w64 %1) {
8 +
  @entry0
9 +
    sub w64 %2 %0 %1;
10 +
    ret %2;
11 +
}
12 +
13 +
fn w64 $mulI64(w64 %0, w64 %1) {
14 +
  @entry0
15 +
    mul w64 %2 %0 %1;
16 +
    ret %2;
17 +
}
18 +
19 +
fn w64 $addU64(w64 %0, w64 %1) {
20 +
  @entry0
21 +
    add w64 %2 %0 %1;
22 +
    ret %2;
23 +
}
24 +
25 +
fn w64 $subU64(w64 %0, w64 %1) {
26 +
  @entry0
27 +
    sub w64 %2 %0 %1;
28 +
    ret %2;
29 +
}
30 +
31 +
fn w64 $mulU64(w64 %0, w64 %1) {
32 +
  @entry0
33 +
    mul w64 %2 %0 %1;
34 +
    ret %2;
35 +
}
36 +
37 +
fn w64 $shlU64(w64 %0, w64 %1) {
38 +
  @entry0
39 +
    shl w64 %2 %0 %1;
40 +
    ret %2;
41 +
}
42 +
43 +
fn w64 $shrI64(w64 %0, w64 %1) {
44 +
  @entry0
45 +
    sshr w64 %2 %0 %1;
46 +
    ret %2;
47 +
}
48 +
49 +
fn w64 $divI64(w64 %0, w64 %1) {
50 +
  @entry0
51 +
    sdiv w64 %2 %0 %1;
52 +
    ret %2;
53 +
}
54 +
55 +
fn w64 $divU64(w64 %0, w64 %1) {
56 +
  @entry0
57 +
    udiv w64 %2 %0 %1;
58 +
    ret %2;
59 +
}
60 +
61 +
fn w64 $widenI32ToI64(w32 %0) {
62 +
  @entry0
63 +
    sext w32 %1 %0;
64 +
    ret %1;
65 +
}
66 +
67 +
fn w64 $widenU32ToU64(w32 %0) {
68 +
  @entry0
69 +
    zext w32 %1 %0;
70 +
    ret %1;
71 +
}
72 +
73 +
fn w32 $narrowI64ToI32(w64 %0) {
74 +
  @entry0
75 +
    sext w32 %1 %0;
76 +
    ret %1;
77 +
}
78 +
79 +
fn w32 $narrowU64ToU32(w64 %0) {
80 +
  @entry0
81 +
    zext w32 %1 %0;
82 +
    ret %1;
83 +
}
lib/std/lang/parser.rad +8 -0
1974 1974
        }
1975 1975
        case scanner::TokenKind::U32 => {
1976 1976
            advance(p);
1977 1977
            return nodeTypeInt(p, 4, ast::Signedness::Unsigned);
1978 1978
        }
1979 +
        case scanner::TokenKind::U64 => {
1980 +
            advance(p);
1981 +
            return nodeTypeInt(p, 8, ast::Signedness::Unsigned);
1982 +
        }
1979 1983
        case scanner::TokenKind::I8 => {
1980 1984
            advance(p);
1981 1985
            return nodeTypeInt(p, 1, ast::Signedness::Signed);
1982 1986
        }
1983 1987
        case scanner::TokenKind::I16 => {
1986 1990
        }
1987 1991
        case scanner::TokenKind::I32 => {
1988 1992
            advance(p);
1989 1993
            return nodeTypeInt(p, 4, ast::Signedness::Signed);
1990 1994
        }
1995 +
        case scanner::TokenKind::I64 => {
1996 +
            advance(p);
1997 +
            return nodeTypeInt(p, 8, ast::Signedness::Signed);
1998 +
        }
1991 1999
        case scanner::TokenKind::Bool => {
1992 2000
            advance(p);
1993 2001
            return node(p, ast::NodeValue::TypeSig(ast::TypeSig::Bool));
1994 2002
        }
1995 2003
        case scanner::TokenKind::Void => {
lib/std/lang/resolver.rad +21 -3
199 199
    /// Types only used during inference.
200 200
    Nil, Undefined, Int,
201 201
    /// Primitive types.
202 202
    Void, Opaque, Never, Bool,
203 203
    /// Integer types.
204 -
    U8, U16, U32, I8, I16, I32,
204 +
    U8, U16, U32, U64, I8, I16, I32, I64,
205 205
    /// Range types, eg. `start..end`.
206 206
    Range {
207 207
        start: ?*Type,
208 208
        end: ?*Type,
209 209
    },
1224 1224
}
1225 1225
1226 1226
/// Check if a type is a numeric type.
1227 1227
fn isNumericType(ty: Type) -> bool {
1228 1228
    match ty {
1229 -
        case Type::U8, Type::U16, Type::U32,
1230 -
             Type::I8, Type::I16, Type::I32,
1229 +
        case Type::U8, Type::U16, Type::U32, Type::U64,
1230 +
             Type::I8, Type::I16, Type::I32, Type::I64,
1231 1231
             Type::Int => return true,
1232 1232
        else => return false,
1233 1233
    }
1234 1234
}
1235 1235
1248 1248
        case Type::Void, Type::Never => return Layout { size: 0, alignment: 0 },
1249 1249
        case Type::Bool => return Layout { size: 1, alignment: 1 },
1250 1250
        case Type::U8, Type::I8 => return Layout { size: 1, alignment: 1 },
1251 1251
        case Type::U16, Type::I16 => return Layout { size: 2, alignment: 2 },
1252 1252
        case Type::U32, Type::I32, Type::Int => return Layout { size: 4, alignment: 4 },
1253 +
        case Type::U64, Type::I64 => return Layout { size: 8, alignment: 8 },
1253 1254
        case Type::Pointer { .. } => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
1254 1255
        case Type::Slice { .. } => return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
1255 1256
        case Type::Array(arr) => return getArrayLayout(arr),
1256 1257
        case Type::Optional(inner) => return getOptionalLayout(*inner),
1257 1258
        case Type::Nominal(info) => return getNominalLayout(*info),
1401 1402
            bits: 32,
1402 1403
            min: I32_MIN,
1403 1404
            max: I32_MAX,
1404 1405
            lim: (I32_MAX as u32) + 1,
1405 1406
        },
1407 +
        // Immediates are 32-bit here and sign-extended when widened, so only
1408 +
        // the `i32` subset of the `i64` range is representable.
1409 +
        case Type::I64 => return IntegerRange::Signed {
1410 +
            bits: 64,
1411 +
            min: I32_MIN,
1412 +
            max: I32_MAX,
1413 +
            lim: (I32_MAX as u32) + 1,
1414 +
        },
1406 1415
        case Type::Int => return IntegerRange::Signed {
1407 1416
            bits: 32,
1408 1417
            min: I32_MIN,
1409 1418
            max: I32_MAX,
1410 1419
            lim: (I32_MAX as u32) + 1,
1411 1420
        },
1412 1421
        case Type::U8 => return IntegerRange::Unsigned { bits: 8, max: U8_MAX },
1413 1422
        case Type::U16 => return IntegerRange::Unsigned { bits: 16, max: U16_MAX },
1414 1423
        case Type::U32 => return IntegerRange::Unsigned { bits: 32, max: parser::U32_MAX },
1424 +
        // Likewise, only values below `2^31` survive sign-extension intact.
1425 +
        case Type::U64 => return IntegerRange::Unsigned { bits: 64, max: I32_MAX as u32 },
1415 1426
        else => return nil,
1416 1427
    }
1417 1428
}
1418 1429
1419 1430
/// Validate that an integer constant fits within the target type's range.
5207 5218
                        return Type::U32;
5208 5219
                    } else {
5209 5220
                        return Type::I32;
5210 5221
                    }
5211 5222
                }
5223 +
                case 8 => {
5224 +
                    if sign == ast::Signedness::Unsigned {
5225 +
                        return Type::U64;
5226 +
                    } else {
5227 +
                        return Type::I64;
5228 +
                    }
5229 +
                }
5212 5230
                else => {
5213 5231
                    panic "resolveTypeSig: invalid integer width";
5214 5232
                }
5215 5233
            }
5216 5234
        }
lib/std/lang/resolver/printer.rad +6 -0
66 66
            io::print("u16");
67 67
        }
68 68
        case super::Type::U32 => {
69 69
            io::print("u32");
70 70
        }
71 +
        case super::Type::U64 => {
72 +
            io::print("u64");
73 +
        }
71 74
        case super::Type::I8 => {
72 75
            io::print("i8");
73 76
        }
74 77
        case super::Type::I16 => {
75 78
            io::print("i16");
76 79
        }
77 80
        case super::Type::I32 => {
78 81
            io::print("i32");
79 82
        }
83 +
        case super::Type::I64 => {
84 +
            io::print("i64");
85 +
        }
80 86
        case super::Type::Pointer { target, mutable } => {
81 87
            io::print("*");
82 88
            if mutable {
83 89
                io::print("mut ");
84 90
            }
lib/std/lang/scanner.rad +6 -2
101 101
102 102
    // Type or function attributes.
103 103
    Pub, Extern, Static,
104 104
105 105
    // Type-related tokens.
106 -
    I8, I16, I32, U8, U16, U32,
106 +
    I8, I16, I32, I64, U8, U16, U32, U64,
107 107
    Void, Opaque, Fn, Bool, Union, Record, As
108 108
}
109 109
110 110
/// Convert a token kind to its string representation.
111 111
pub fn tokenKindToString(kind: TokenKind) -> *[u8] {
198 198
        case TokenKind::Extern => return "Extern",
199 199
        case TokenKind::Static => return "Static",
200 200
        case TokenKind::I8 => return "I8",
201 201
        case TokenKind::I16 => return "I16",
202 202
        case TokenKind::I32 => return "I32",
203 +
        case TokenKind::I64 => return "I64",
203 204
        case TokenKind::U8 => return "U8",
204 205
        case TokenKind::U16 => return "U16",
205 206
        case TokenKind::U32 => return "U32",
207 +
        case TokenKind::U64 => return "U64",
206 208
        case TokenKind::Void => return "Void",
207 209
        case TokenKind::Opaque => return "Opaque",
208 210
        case TokenKind::Fn => return "Fn",
209 211
        case TokenKind::Bool => return "Bool",
210 212
        case TokenKind::Union => return "Union",
220 222
    /// Corresponding token.
221 223
    tok: TokenKind,
222 224
}
223 225
224 226
/// Sorted keyword table for binary search.
225 -
const KEYWORDS: [Keyword; 47] = [
227 +
const KEYWORDS: [Keyword; 49] = [
226 228
    { name: "align", tok: TokenKind::Align },
227 229
    { name: "and", tok: TokenKind::And },
228 230
    { name: "as", tok: TokenKind::As },
229 231
    { name: "bool", tok: TokenKind::Bool },
230 232
    { name: "break", tok: TokenKind::Break },
237 239
    { name: "false", tok: TokenKind::False },
238 240
    { name: "fn", tok: TokenKind::Fn },
239 241
    { name: "for", tok: TokenKind::For },
240 242
    { name: "i16", tok: TokenKind::I16 },
241 243
    { name: "i32", tok: TokenKind::I32 },
244 +
    { name: "i64", tok: TokenKind::I64 },
242 245
    { name: "i8", tok: TokenKind::I8 },
243 246
    { name: "if", tok: TokenKind::If },
244 247
    { name: "in", tok: TokenKind::In },
245 248
    { name: "let", tok: TokenKind::Let },
246 249
    { name: "log", tok: TokenKind::Log },
262 265
    { name: "throws", tok: TokenKind::Throws },
263 266
    { name: "true", tok: TokenKind::True },
264 267
    { name: "try", tok: TokenKind::Try },
265 268
    { name: "u16", tok: TokenKind::U16 },
266 269
    { name: "u32", tok: TokenKind::U32 },
270 +
    { name: "u64", tok: TokenKind::U64 },
267 271
    { name: "u8", tok: TokenKind::U8 },
268 272
    { name: "undefined", tok: TokenKind::Undefined },
269 273
    { name: "union", tok: TokenKind::Union },
270 274
    { name: "use", tok: TokenKind::Use },
271 275
    { name: "void", tok: TokenKind::Void },
vim/radiance.vim +1 -1
17 17
" Keywords
18 18
syntax keyword radianceKeyword mod fn return if else while true false and or not case align static
19 19
syntax keyword radianceKeyword pub extern break continue use loop in for match nil undefined
20 20
syntax keyword radianceKeyword let mut as register device const log record union
21 21
syntax keyword radianceKeyword throws throw try catch panic super
22 -
syntax keyword radianceType i8 i16 i32 u8 u16 u32 f32 void bool bit opaque
22 +
syntax keyword radianceType i8 i16 i32 i64 u8 u16 u32 u64 f32 void bool bit opaque
23 23
24 24
" Double-quoted strings
25 25
syntax region radianceString start=/"/ skip=/\\"/ end=/"/ contains=radianceEscape
26 26
" Characters
27 27
syntax region radianceCharacter start=/'/ skip=/\\'|\\\\/ end=/'/ oneline contains=radianceEscape