hl-valdemar/honey
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Wiki Activity

feat: support optional-capture conditional expressions

Browse Source 
Reuse canonical matches for optional presence and exact by-value payload captures across checking, lowering and compile-time selection.

Snapshot the optional-match flag before selector construction: AST additions can reallocate storage and invalidate the borrowed tree until refresh.

Verified 268 bootstrap tests and 908 interpreter/native programs at -O0 and -O2, plus native allocator, LLVM and CLI checks.
This commit is contained in:
Valdemar Høgsvig Lorenzen
2026-10-29 22:20:48 +01:00
parent 46fc7f4c46
commit 9838b253ee
9 changed files with 293 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+1 -1
View File
@@ -200,7 +200,7 @@ enums use `Kind :: enum { number, empty }`, qualified members such as `Kind.numb
untagged `Bits :: union { integer u64, real f64 }` overlays its members in shared storage. keyed construction selects exactly one member; reading another member reinterprets the same bytes. tagged unions use `union(enum)` or `union(Kind)`; an explicit enum must contain every union variant. construct them with `Choice { number = 42 }`, contextual `.number{42}`, `.point{x = 40, y = 2}` for record payloads, or `.empty` for `void` payloads. field reads/writes validate the active tag. nested aggregates copy by value, including across calls. CLI union results print `{payload}` (or `{}` for a void payload); untagged results print the first member.
`if (guard) then_value else else_value` is a boolean value expression. the guard runs once and only the selected expression executes; `else` is required and binds to the nearest conditional. both runtime branches must fit the result context, including optional/fallible channels and aggregate copies. constant-input procedures, direct `$()` evaluation, generic branch specialization and generated type positions reuse checked match execution. guards require parentheses unless they are calls or explicit `$()` expressions. parenthesize a conditional used as a match-arm value to distinguish it from an `if` statement. optional payload captures and yielding value blocks remain unsupported.
`if (guard) then_value else else_value` is a boolean value expression. `if value |payload| then_value else else_value` instead tests optional presence and binds the exact payload as an immutable by-value capture in the then expression; nested optionals preserve present-null payloads. the guard runs once and only the selected expression executes; `else` is required and binds to the nearest conditional. both runtime branches must fit the result context, including optional/fallible channels and aggregate copies. constant-input procedures, direct `$()` evaluation, generic branch specialization, explicit compile-time subject selection and generated type positions reuse checked match execution. boolean guards require parentheses unless they are calls or explicit `$()` expressions; optional captures also permit bare guards. parenthesize a conditional used as a match-arm value to distinguish it from an `if` statement. yielding value blocks remain unsupported.
`match value { .number |n|: n + 2, .empty: 0 }` selects one arm after evaluating its subject once. matches support enums, tagged unions, composed error sets, numeric/boolean scalars, comma-separated patterns, numeric ranges, final `else` arms, arm-local payload captures, statement bodies and expression results. checking rejects missing coverage, duplicate/overlapping patterns, unreachable arms and incompatible captures/results. block arms can return or transfer loop control; yielding value blocks and pointer captures belong to later gates.
TODO.md
+6 -4
View File
@@ -56,8 +56,9 @@ runtime `undefined` locals and compute fully initialized materializable constant
the existing `ArrayList` uses nested generic inference, file-local helpers and
the real imported C allocator through native execution; interpreter checks use
non-FFI allocators and cover zero-sized storage, growth, failure and cleanup.
boolean `if ... else` expressions reuse checked matches for runtime/constant values,
contextual optional/fallible results and generated types; yielding blocks remain open.
boolean and optional-capture `if ... else` expressions reuse checked matches for
runtime/constant values, contextual optional/fallible results and generated types;
yielding blocks remain open.
the driver retains frontend storage and source provenance through
`@source/compilation`, with compilation-wide AST node identities.
file commands retain single-file behavior; directory commands compile the
@@ -124,9 +125,10 @@ test discovery and FFI remain outside these completed slices.
- [x] type-metadata reflection checkpoint: `typeinfo!(T)` uses the actual `@std/meta` ABI to classify supported types and expose array child/length, immediate distinct backing, record names/tuple/layout and enum/record fields through interpreter/native execution. readonly owned metadata collections retain exact nominal/type leaves, ordinal indices, composed enum identity, checked projections, by-value iteration/copies and compile-time procedure boundaries. ordinary/inline matches select runtime bodies; reflected fields drive `field!`, generics and generated storage/defaults. arity/type/import/ABI failures, match/capture validation, bounds, readonly updates, runtime escape rejection, imported provenance, shared construction bounds and repeatable compilation retain diagnostics and ownership. existing `meta.EnumFieldStruct` and `enummap.EnumMap` generated storage are verified without replacement library code; full `enummap.init/get` is covered below, while general type-valued execution and broader constant materialization remain open.
- [x] enum-map acceptance checkpoint: existing `enummap.init/get` run through interpreter/native execution with sparse/aliased/composed enum keys, absent entries and owned aggregate values. contextual `.tag` and aggregate arguments reuse key/value types inferred from rigid generated-map arguments; unresolved generics and rigid conflicts still diagnose. `some!` constructs exact, single-evaluation optional payloads and preserves nested present-null values through compile-time results, cache keys and generated defaults. concrete mutable runtime locals initialize from `undefined`, including nested record/array updates, pointer access and by-value copies; ordinary compile-time procedures materialize fully initialized storage and reject incomplete snapshots. native undefined storage is poison, not zeroed or per-leaf checked. `get` now explicitly returns `null` on lookup fallthrough, preserving the ordinary nonvoid return contract.
- [x] array-list acceptance checkpoint: existing `std/arraylist` and `std/mem` initialize, reserve/grow, append/pop/clear and release ordinary/aggregate/zero-sized storage without replacement library code. nested generic inference canonicalizes generated types through pointers and derives exact slice `.ptr` types; rigid conflicts remain diagnostic. `minval!`/`maxval!` preserve integer types and checked `divtrunc!` traps on zero and signed overflow through interpreter/native execution. file-local helpers retain real `@hide:file` visibility, newline `else` preserves match default arms, and repeated `_` parameters remain sinks. generated C records, nominal opaque pointers and foreign callbacks load from existing `ffi/c`; unused unsupported signatures neither diagnose nor emit external symbols, while demanded unsupported ABI/types diagnose. interpreter fixed-capacity allocator checks cover failure without losing storage and deferred error cleanup; native `mem.c_allocator` checks cover aggregate growth and over-aligned allocation/reallocation at `-O0`/`-O2`. arbitrary interpreter FFI, variadic/aggregate C calls and broader library acceptance remain open.
- [x] boolean conditional-expression checkpoint: `if (guard) then_value else else_value` reuses canonical matches through interpreter/native execution. guards evaluate once and only the selected expression executes; nested conditionals bind `else` to the nearest conditional. exact result types, aggregate copy isolation, contextual optional/fallible channels, direct `$()` values, constant-input procedures, generic branch selection and nested generated type positions retain existing checked execution. missing `else`, nonboolean guards and incompatible runtime branch types diagnose. optional captures, yielding value blocks, compound updates and bitwise operators remain open before hash-map acceptance.
- [x] boolean conditional-expression checkpoint: `if (guard) then_value else else_value` reuses canonical matches through interpreter/native execution. guards evaluate once and only the selected expression executes; nested conditionals bind `else` to the nearest conditional. exact result types, aggregate copy isolation, contextual optional/fallible channels, direct `$()` values, constant-input procedures, generic branch selection and nested generated type positions retain existing checked execution. missing `else`, nonboolean guards and incompatible runtime branch types diagnose. optional captures are covered below; yielding value blocks, compound updates and bitwise operators remain open before hash-map acceptance.
- [x] optional conditional-expression checkpoint: `if value |payload| then_value else else_value` reuses canonical presence matches through interpreter/native execution. single-evaluation guards and lazy branches preserve exact immutable by-value captures, nested optional presence, aggregate isolation and runtime pointer/callback/slice/zero-sized payloads. contextual optional/fallible results, constant-input procedures, generated types/defaults and explicit compile-time subject selection retain checked execution and owned payload snapshots. nonoptional guards, capture scope/shadowing, malformed captures, missing `else`, incompatible branches and compile-time overflow retain diagnostics. yielding value blocks and broader constant materialization remain open.
- [ ] remaining gate: general type-valued compile-time execution, broader constant materialization (including untagged unions and storage-bearing values), plus full existing-library acceptance for hash maps, broader `meta` operations and `io.print`. required expression-valued control flow, compound updates, formatting parsing and broader imported C-binding support may interleave with later gates.
- [ ] remaining source constructs: optional-capture conditional expressions, yielding value blocks and `yield`, compound updates, bitwise operators and multiline strings. boolean conditional expressions are covered above. examples: `source/parser/parse.hon`, `source/llvm/runtime.hon`.
- [ ] remaining source constructs: yielding value blocks and `yield`, compound updates, bitwise operators and multiline strings. boolean and optional-capture conditional expressions are covered above. examples: `source/parser/parse.hon`, `source/llvm/runtime.hon`.
- [ ] standard-library milestone: compile/run a multi-package program exercising existing allocation and IO, including error cleanup; no replacement miniature standard library.
- [ ] native driver integration: required C ABI declarations, `process.Init` startup arguments/IO, actual CLI exit statuses, file loading, temporary files and spawning Clang. Honey-generated programs currently accept only parameterless `main` and print its result; Bro's bootstrap startup support is not Honey backend support.
- [ ] self-hosting proof: bootstrap-built Honey builds the production compiler (excluding test-only imports); that executable rebuilds the compiler; the rebuilt compiler passes representative interpreter/native examples and CLI/error scenarios without Bro at runtime.
source/ast/ast.hon
+24 -4
View File
@@ -7,7 +7,7 @@
#! * decl ..... -> identifier [type] binding expr | identifier 'c_func' '(' parameters ')' type | ['test'] [identifier '::'] 'import' string
#! * parameters -> [['$'] identifier {',' ['$'] identifier} type {',' ['$'] identifier {',' ['$'] identifier} type} [',']]; '$' marks each compile-time parameter independently.
#! '$(' expr ')' is an explicit compile-time expression with primary-expression precedence.
#! boolean value expressions also accept 'if' guard expr 'else' expr, canonicalized to matches; else is required.
#! value expressions also accept 'if' guard ['|' identifier '|'] expr 'else' expr, canonicalized to matches; else is required.
#! * block .... -> '{' {stmt} '}'
#! * arm ...... -> block | stmt (single statements become canonical blocks)
#! * match_arm -> (expr {',' expr} ['|' identifier '|'] | 'else') ':' (block | stmt | expr); arms are comma/newline separated.
@@ -207,6 +207,7 @@ NodeData :: union {
@hide:file foreign_type_flag u8 :: 0b0010
@hide:file variadic_flag u8 :: 0b0100
@hide:file opaque_flag u8 :: 0b1000
@hide:file optional_match_flag u8 :: 0b0001_0000
@hide:file
Node :: struct {
@@ -348,8 +349,17 @@ FieldView :: struct {
}
EnumTypeView :: struct { backing ?NodeId }
UnionTypeView :: struct { tag ?NodeId, auto_tag bool }
MatchView :: struct { subject NodeId }
UnionTypeView :: struct {
tag ?NodeId,
auto_tag bool,
}
MatchView :: struct {
subject NodeId,
optional_capture bool = false,
}
MatchArmView :: struct {
capture ?NodeId
body NodeId
@@ -833,6 +843,13 @@ add_match proc(builder @mut Builder, span Span, subject NodeId, arms []NodeId) N
}, span)
}
#! marks the canonical presence match emitted for an optional-capture conditional.
set_match_optional proc(builder @mut Builder, id NodeId) void {
node :: &builder.storage.nodes.items[usize(id)]
debug.assert(node.kind == .expr_match)
node.flags = node.flags | optional_match_flag
}
add_match_arm proc(
builder @mut Builder, span Span, patterns []NodeId, capture ?NodeId,
body NodeId, expression, catch_all bool,
@@ -1747,7 +1764,10 @@ enum_literal proc(tree @Tree, id NodeId) NodeId {
match_expr proc(tree @Tree, id NodeId) MatchView {
node :: get_node(&tree.storage, id)
debug.assert(node.kind == .expr_match)
return MatchView{ subject = node.main.node_id }
return MatchView{
subject = node.main.node_id,
optional_capture = (node.flags & optional_match_flag) != 0,
}
}
match_arm_count proc(tree @Tree, id NodeId) usize {
source/compilation/compilation.test.hon
+9
View File
@@ -528,8 +528,17 @@ recompiles_generated_records_without_borrowing_previous_ir test {
` [child, 2, "owned"],
` )
`}
`Captured proc(value ?i16) type {
` return if value |payload| struct { value i16 = payload } else bool
`}
`selected proc($value ?i16) i16 {
` return if $(value) |payload| payload else 7
`}
`main proc() i16 {
` parent Parent(40) :: {}
` captured Captured(40) :: {}
` absent Captured(null) :: false
` if (absent or captured.value != selected(40) or selected(null) != 7) return 0
` same Parent(40) :: parent
` child Child(40) :: same.child
` if (Child(40) == Child(41) or Parent(40) == Parent(41)) return 0
source/lower/lower.hon
+2
View File
@@ -1043,6 +1043,7 @@ lower_match proc(state @mut State, id ast.NodeId) ir.ValueId ! (mem.AllocError |
subject_type :: typecheck.type_of(state.checked, view.subject)
tagged :: subject_type.kind == .record
discriminant := subject
if (view.optional_capture) discriminant = try optional_present(state, subject, subject_type, span)
if (tagged) {
tag_type :: typecheck.record_type(state.checked, subject_type.record_type).tag_type
discriminant = try emit(state, ir.Instruction{
@@ -1095,6 +1096,7 @@ lower_match proc(state @mut State, id ast.NodeId) ir.ValueId ! (mem.AllocError |
if (arm_view.capture) |capture| {
capture_type :: typecheck.type_of(state.checked, capture)
captured := subject
if (view.optional_capture) captured = try optional_payload(state, subject, subject_type, span)
if (tagged) captured = try emit(state, ir.Instruction{
op = .field, type = lower_type(state, capture_type), array_type = try array_shape(state, capture_type),
left = subject, slot = u32(typecheck.union_variant_index(state.checked, pattern)), span = ast.node_span(tree, pattern),
source/parser/parse.hon
+6 -3
View File
@@ -465,6 +465,7 @@ parse_if proc(state @mut State) ast.NodeId ! ParseError {
parse_if_expr proc(state @mut State) ast.NodeId ! ParseError {
keyword :: try consume(state, .if)
condition :: try parse_guard(state)
capture :: try parse_optional_capture(state)
then_value :: try parse_expr(state)
skip_newlines(state)
if (!next_is(state, .else) or next_n_is(state, 1, .colon)) return .unexpected_token
@@ -476,18 +477,20 @@ parse_if_expr proc(state @mut State) ast.NodeId ! ParseError {
end = ast.builder_span(state.builder, else_value).end,
source = keyword.span.source,
}
# canonical boolean matches share inference, specialization and branch execution.
# canonical matches share inference, specialization and branch execution.
patterns [1]ast.NodeId :: [try ast.add_boolean(state.builder, keyword.span, true)]
then_arm :: try ast.add_match_arm(
state.builder, ast.builder_span(state.builder, then_value),
patterns[..], null, then_value, true, false,
patterns[..], capture, then_value, true, false,
)
else_arm :: try ast.add_match_arm(
state.builder, ast.builder_span(state.builder, else_value),
&[], null, else_value, true, true,
)
arms [2]ast.NodeId :: [then_arm, else_arm]
return try ast.add_match(state.builder, span, condition, arms[..])
result :: try ast.add_match(state.builder, span, condition, arms[..])
if (capture != null) ast.set_match_optional(state.builder, result)
return result
}
@hide:file
source/sema/check/check.hon
+32 -6
View File
@@ -4118,6 +4118,9 @@ collect_match proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | dia
state.cells[usize(capture)].local = true
binding :: sema.binding(state.resolution, capture)
if (binding.kind == .invalid) state.cells[usize(capture)].type = invalid_type(binding.data.diagnostic)
if (ast.match_expr(state.tree, id).optional_capture and i == 0) {
state.cells[usize(subject)].capture = capture
}
try depend(state, capture, arm.body)
}
saved_arm :: state.narrowing_arm
@@ -4135,12 +4138,21 @@ collect_match proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | dia
@hide:file
infer_match proc(state @mut State, id ast.NodeId, defaults bool) Type ! (mem.AllocError | diagnostics.CapacityError) {
subject :: try infer_shape(state, ast.match_expr(state.tree, id).subject, defaults)
view :: ast.match_expr(state.tree, id)
subject :: try infer_shape(state, view.subject, defaults)
if (subject.kind == .invalid) {
seed(state, id, subject)
return subject
}
key := subject
if (view.optional_capture) {
if (subject.kind != .none and subject.kind != .optional) {
try fail(state, id, .condition_not_bool, ast.node_span(state.tree, view.subject))
seed(state, id, state.types[usize(id)])
return state.types[usize(id)]
}
if (subject.kind == .optional) key = Type{ kind = .bool }
}
tagged := false
if (subject.kind == .record) {
descriptor :: state.records.items[usize(subject.record_type)]
@@ -4151,7 +4163,7 @@ infer_match proc(state @mut State, id ast.NodeId, defaults bool) Type ! (mem.All
if (tagged) key = descriptor.tag_type
}
if (
subject.kind != .none and !numeric_kind(subject.kind) and subject.kind != .bool
!view.optional_capture and subject.kind != .none and !numeric_kind(subject.kind) and subject.kind != .bool
and !(subject.kind == .enumeration and subject.nominal == ast.NodeId(maxval!(u32))) and !tagged
) {
try fail(state, id, .invalid_match_subject, ast.node_span(state.tree, id))
@@ -4167,6 +4179,10 @@ infer_match proc(state @mut State, id ast.NodeId, defaults bool) Type ! (mem.All
arm :: ast.match_arm_view(state.tree, arm_id)
payload := Type{}
capture_valid := tagged and !arm.catch_all
if (view.optional_capture and subject.kind == .optional and i == 0) {
payload = state.arrays.items[usize(subject.array_type)].element
capture_valid = true
}
for 0..ast.match_pattern_count(state.tree, arm_id) |j| {
pattern :: ast.match_pattern(state.tree, arm_id, j)
kind :: ast.expr_kind(state.tree, pattern)
@@ -4191,7 +4207,7 @@ infer_match proc(state @mut State, id ast.NodeId, defaults bool) Type ! (mem.All
}
}
if (arm.capture) |capture| {
if (key.kind != .none and (!capture_valid or payload.kind == .void or payload.kind == .none)) {
if (key.kind != .none and (!capture_valid or (!view.optional_capture and payload.kind == .void) or payload.kind == .none)) {
try fail(state, id, .invalid_match_capture, ast.node_span(state.tree, capture))
} else if (payload.kind != .none and state.cells[usize(capture)].type.kind != .invalid) {
seed(state, capture, payload)
@@ -4317,9 +4333,17 @@ interval_overlap proc(left, right PatternInterval) bool {
@hide:file
validate_match proc(state @mut State, id ast.NodeId) void ! (mem.AllocError | diagnostics.CapacityError) {
subject :: state.types[usize(ast.match_expr(state.tree, id).subject)]
view :: ast.match_expr(state.tree, id)
subject :: state.types[usize(view.subject)]
if (subject.kind == .invalid) return
key := subject
if (view.optional_capture) {
if (subject.kind != .optional) {
try fail(state, id, .condition_not_bool, ast.node_span(state.tree, view.subject))
return
}
key = Type{ kind = .bool }
}
if (subject.kind == .record) key = state.records.items[usize(subject.record_type)].tag_type
if (key.kind != .enumeration and !numeric_kind(key.kind) and key.kind != .bool) {
try fail(state, id, .invalid_match_subject, ast.node_span(state.tree, id))
@@ -4724,9 +4748,11 @@ matching_narrowing_arm proc(state @State, id ast.NodeId) ast.NodeId {
arm := state.cells[usize(id)].narrowing_arm
while (arm != ast.NodeId(maxval!(u32))) {
owner :: state.cells[usize(arm)].match_owner
subject :: ast.match_expr(state.tree, owner).subject
original :: sema.binding(state.resolution, subject)
view :: ast.match_expr(state.tree, owner)
if (!view.optional_capture) {
original :: sema.binding(state.resolution, view.subject)
if (original.kind == .declaration and original.data.declaration == binding.data.declaration) return arm
}
arm = state.cells[usize(arm)].enclosing_arm
}
return ast.NodeId(maxval!(u32))
source/sema/specialize/specialize.hon
+21 -3
View File
@@ -1335,14 +1335,22 @@ specialize_match proc(state @mut State, id, statement ast.NodeId) bool ! Error {
annotation = try expression_type(state, subject, 0)
if (annotation != no_node) annotation = try inline_match_shape(state, annotation)
}
if (annotation == no_node or ast.expr_kind(&state.tree, annotation) != .union_type) break
if (annotation == no_node) break
payload := no_node
if (ast.match_expr(&state.tree, id).optional_capture) {
if (ast.expr_kind(&state.tree, annotation) != .optional_type) break
payload = ast.type_operand(&state.tree, annotation)
} else {
if (ast.expr_kind(&state.tree, annotation) != .union_type) break
pattern :: ast.match_pattern(&state.tree, arm_id, 0)
if (ast.expr_kind(&state.tree, pattern) != .enum_literal) continue
slot :: type_record_slot(state, annotation, ast.enum_literal(&state.tree, pattern))
if (slot == no_index) continue
field :: ast.field(&state.tree, ast.record_field(&state.tree, annotation, slot))
if (field.type) |type| {
hashmap.put(&state.capture_types, arm.capture?, type) catch |err| {
if (field.type) |type| payload = type
}
if (payload != no_node) {
hashmap.put(&state.capture_types, arm.capture?, payload) catch |err| {
match err {
.key_exists: unreachable
else: return err
@@ -2508,6 +2516,7 @@ expand_inline_for proc(state @mut State, id ast.NodeId) void ! Error {
type_match_arm proc(state @mut State, id ast.NodeId) usize ! Error {
try expand_inline_match(state, id, no_node)
if (ast.expr_kind(&state.tree, id) != .match_expr) return no_index
optional_capture :: ast.match_expr(&state.tree, id).optional_capture
if (!try expand_type_matches(state, ast.match_expr(&state.tree, id).subject)) return no_index
try expand(state, ast.match_expr(&state.tree, id).subject)
arms := arraylist.init(ast.NodeId, state.allocator)
@@ -2581,6 +2590,8 @@ type_match_arm proc(state @mut State, id ast.NodeId) usize ! Error {
}
selector :: try ast.add_match(state.builder, ast.node_span(&state.tree, id),
dispatch, arms.items)
if (optional_capture)
ast.set_match_optional(state.builder, selector)
try refresh(state)
# selector arms contain only indices. do not specialize this synthetic match
# again while its checked evaluation expands the wrapper.
@@ -2595,6 +2606,13 @@ type_match_arm proc(state @mut State, id ast.NodeId) usize ! Error {
@hide:file
type_match_capture proc(state @mut State, id ast.NodeId) ast.NodeId ! Error {
subject :: ast.match_expr(&state.tree, id).subject
if (ast.match_expr(&state.tree, id).optional_capture) {
unwrapped :: try ast.add_unary(state.builder,
ast.node_span(&state.tree, subject), .unwrap, subject)
try refresh(state)
child :: try expression_type(state, unwrapped, 0)
return try type_execution_value(state, unwrapped, child)
}
annotation :: try expression_type(state, subject, 0)
value :: if (type_record_storage(state, annotation, 0))
try evaluate_expected(state, subject, annotation) else try evaluate_ir(state, subject, annotation)
tests/native.py
+186
View File
@@ -110,6 +110,192 @@ CASES = {
"main proc() i16 { return if (1) 42 else 0 }",
b"", b"incompatible value type",
),
"optional_conditional_expressions_evaluate_once_and_keep_branches_lazy": (
"""
next proc(calls @mut i16, value ?i16) ?i16 {
calls^ = calls^ + 1
return value
}
main proc() [3]i16 {
calls i16 := 0
first i16 :: if next(&calls, 42) |payload| payload else divtrunc!(1, 0)
second i16 :: if next(&calls, null) |payload| divtrunc!(payload, 0) else 7
return [first, second, calls]
}
""", b"[42, 7, 2]\n", None,
),
"optional_conditional_expressions_keep_nested_presence_and_else_binding": (
"""
identity proc($T type, value T) T { return value }
choose proc(value ??i16) i16 {
return if value |inner| if identity(inner) |payload| payload else 7 else 3
}
main proc() [3]i16 {
return [choose(some!(null)), choose(null), choose(some!(some!(42)))]
}
""", b"[7, 3, 42]\n", None,
),
"optional_conditional_expressions_snapshot_aggregate_payloads": (
"""
Item :: struct { values [1]mut i16 }
replace proc(value @mut ?Item) i16 {
value^ = Item { values = [0] }
return 0
}
main proc() [2]i16 {
original ?Item := Item { values = [42] }
saved i16 :: if original |payload| replace(&original) + payload.values[0] else -1
return [saved, (original?).values[0]]
}
""", b"[42, 0]\n", None,
),
"optional_conditional_expressions_preserve_narrow_payload_types": (
"""
identity proc($T type, value T) T { return value }
exact proc(value i8) i16 { return i16(value) }
choose proc(value ?i8) i16 { return if value |payload| exact(identity(payload)) else 7 }
main proc() [2]i16 { return [choose(42), choose(null)] }
""", b"[42, 7]\n", None,
),
"optional_conditional_expressions_capture_pointer_callback_slice_and_zero_size": (
"""
increment proc(value i16) i16 { return value + 2 }
read_pointer proc(value ?@i16) i16 { return if value |pointer| pointer^ else 7 }
invoke proc(value ?@proc(value i16) i16) i16 {
return if value |callback| callback(40) else 8
}
sum proc(value ?[]i16) i16 {
return if value |items| items[0] + items[1] else 9
}
empty proc(value ?[0]i16) i16 { return if value |items| i16(items.len) else 10 }
main proc() [8]i16 {
value i16 :: 42
items [2]i16 :: [19, 23]
return [read_pointer(&value), read_pointer(null), invoke(increment), invoke(null),
sum(items[..]), sum(null), empty([]), empty(null)]
}
""", b"[42, 7, 42, 8, 42, 9, 0, 10]\n", None,
),
"optional_conditional_expressions_preserve_optional_and_fallible_context": (
"""
Error :: enum { failed }
optional proc(value ?i16) ?i16 { return if value |payload| payload + 2 else null }
fallible proc(value ?i16) i16 ! Error {
return if value |payload| payload + 2 else .failed
}
main proc() [3]i16 {
if (optional(null) != null) return [0, 0, 0]
return [optional(40)?, fallible(40) catch 0, fallible(null) catch 7]
}
""", b"[42, 42, 7]\n", None,
),
"optional_conditional_expressions_materialize_compile_time_scalars": (
"""
choose proc(value ?i8) i16 { return if value |payload| i16(payload) + 2 else 7 }
nested proc(value ??i16) i16 {
return if value |inner| if inner |payload| payload else 11 else 13
}
main proc() [4]i16 {
return [$(choose(40)), $(choose(null)), $(nested(some!(null))), $(nested(null))]
}
""", b"[42, 7, 11, 13]\n", None,
),
"optional_conditional_expressions_generate_types_and_captured_defaults": (
"""
Choose proc(value ?usize) type { return if value |_| i16 else i8 }
Box proc(count ?usize) type {
return if count |length| struct { values [length]i16, bias i16 = i16(length) }
else struct { value i16 = 7 }
}
main proc() [3]i16 {
first Box(2) :: { values = [19, 21] }
same Box(usize(2)) :: first
absent Box(null) :: {}
narrow Choose(null) :: 5
wide Choose(2) :: 40
return [same.values[0] + same.values[1] + same.bias, absent.value,
wide + i16(narrow)]
}
""", b"[42, 7, 45]\n", None,
),
"optional_conditional_expressions_own_compile_time_aggregate_captures": (
"""
Config :: struct { name string, counts [2]usize }
Storage proc(config ?Config) type {
return if config |payload| struct {
items [payload.counts[0]]i16
name string = payload.name
} else struct { value i16 = 7 }
}
main proc() i16 {
value Storage(Config { name = "abc", counts = [2, 1] }) :: { items = [19, 20] }
return value.items[0] + value.items[1] + i16(value.name.len)
}
""", b"42\n", None,
),
"optional_conditional_expressions_specialize_selected_capture_only": (
"""
present proc($value ?i8) i16 {
return if $(value) |payload| i16(payload) + 2 else compile_error!("absent")
}
absent proc($value ?i8) i16 {
return if $(value) |_| compile_error!("present") else 7
}
select proc($value ?i8) i16 {
return if $(value) |payload| i16(payload) + 2 else 7
}
main proc() [6]i16 {
return [present(40), absent(null), select(40), select(null), select(1), select(40)]
}
""", b"[42, 7, 42, 7, 3, 42]\n", None,
),
"optional_conditional_expressions_keep_compile_time_narrow_overflow": (
"""
narrow proc(value ?i8) i8 { return if value |payload| payload + 1 else 0 }
main proc() i8 { return $(narrow(127)) }
""", b"", b"integer arithmetic overflow",
),
"optional_conditional_expressions_reject_runtime_explicit_comptime_subject": (
"""
choose proc(value ?i16) i16 { return if $(value) |payload| payload else 0 }
main proc() i16 { return choose(42) }
""", b"", b"generic argument must be a compile-time value",
),
"optional_conditional_expressions_reject_nonoptional_subject": (
"main proc() i16 { return if true |payload| 42 else 0 }",
b"", b"condition",
),
"optional_conditional_expressions_capture_does_not_reach_else": (
"main proc() i16 { value ?i16 :: null\nreturn if value |payload| 42 else payload }",
b"", b"unknown name",
),
"optional_conditional_expressions_capture_does_not_escape": (
"""
main proc() i16 {
value ?i16 :: 42
saved i16 :: if value |payload| payload else 0
return saved + payload
}
""", b"", b"unknown name",
),
"optional_conditional_expressions_reject_capture_shadowing": (
"main proc() i16 { value ?i16 :: 42\nreturn if value |value| value else 0 }",
b"", b"duplicate name or forbidden shadowing",
),
"optional_conditional_expressions_check_unselected_result_types": (
"""
choose proc(value ?i16) i16 { return if value |payload| payload else u8(7) }
main proc() i16 { return choose(42) }
""", b"42\n", b"incompatible value type",
),
"optional_conditional_expressions_require_else": (
"main proc() i16 { value ?i16 :: 42\nreturn if value |payload| payload }",
b"", b"unexpected token",
),
"optional_conditional_expressions_reject_pointer_capture_syntax": (
"main proc() i16 { value ?i16 :: 42\nreturn if value |@payload| payload^ else 0 }",
b"", b"unexpected token",
),
"integer_divtrunc_preserves_sign_and_single_evaluation": (
"""
next proc(calls @mut i16) i16 { calls^ = calls^ + 1