comptime expandable match statements

compiler/ast/ast.odin

@@ -180,7 +180,7 @@ Stmt :: struct {
 	immutable:  bool,
 	value_control_flow: bool,
 	pointer_capture: bool,
-	inline: bool,
+	expand: bool,
 	error_only: bool,
 	// Assignments store the lvalue in `target`, the right-hand side in `expr`,
 	// and the source operator in `assignment_op`. `Set` is ordinary `=`;
@@ -207,7 +207,8 @@ Stmt :: struct {
 	// list (empty marks the `else` arm; more than one is a multi-pattern arm),
 	// `captures` for the optional payload capture (0 or 1 name, tagged-union variants
 	// only) with `pointer_capture` distinguishing `|@cap|` from `|cap|`, and `body`
-	// as the arm body.
+	// as the arm body. An expanded arm has `expand` set, no patterns, and one or two
+	// captures for its specialized value/payload and optional tagged-union tag.
 	captures:   []symbol.Id,
 	// `Match_Arm` pattern list; empty ⇒ the `else` arm.
 	patterns:   []Expr_Id,

compiler/checker/checker.odin

@@ -59,7 +59,7 @@ Static_Binding :: struct {
 	value: Ct_Value_Id,
 }
 
-Inline_Expansion :: struct {
+Expand_Expansion :: struct {
 	statement: ast.Stmt_Id,
 	index:     u32,
 }
@@ -175,7 +175,7 @@ Type_Factory_Origin :: struct {
 Call_Resolution :: struct {
 	expr:            ast.Expr_Id,
 	ctx:             []Comptime_Value,
-	inline_ctx:      []Inline_Expansion,
+	expand_ctx:      []Expand_Expansion,
 	mapping:         []int,
 	comptime_values: []Comptime_Value,
 	runtime_types:   []types.Type,
@@ -235,7 +235,7 @@ Checker :: struct {
 	static_bindings:         [dynamic]Static_Binding,
 	comptime_keys:           [dynamic]string,
 	comptime_static_values:  [dynamic]Ct_Value_Id,
-	inline_context:          [dynamic]Inline_Expansion,
+	expand_context:          [dynamic]Expand_Expansion,
 	type_factories:       [dynamic]Type_Factory_Entry,
 	generated_types:      [dynamic]Generated_Type_Entry,
 	type_factory_origins: [dynamic]Type_Factory_Origin,
@@ -549,7 +549,21 @@ persistent_field_value :: proc(checker: ^Checker, root: Ct_Value_Id, name: symbo
 }
 
 build_static_value :: proc(checker: ^Checker, value: Ct_Value, span: source.Span, expected: types.Type) -> hir.Expr_Id {
+	if value.kind == .Void {
+		return add_hir_expr(checker, hir.Expr{
+			kind=.Void, span=span, type=types.VOID,
+			target=hir.INVALID_REF, left=hir.INVALID_EXPR, right=hir.INVALID_EXPR,
+			diagnostic=source.INVALID_DIAGNOSTIC,
+		})
+	}
 	if value.kind == .Integer {
+		if types.is_enum(value.type, &checker.module.types) {
+			return add_hir_expr(checker, hir.Expr{
+				kind=.Integer, span=span, type=value.type, integer=i64(value.integer),
+				target=hir.INVALID_REF, left=hir.INVALID_EXPR, right=hir.INVALID_EXPR,
+				diagnostic=source.INVALID_DIAGNOSTIC,
+			})
+		}
 		expr := ast.Expr{
 			kind=.Integer, span=span, integer=u64(value.integer),
 			left=ast.INVALID_EXPR, right=ast.INVALID_EXPR, diagnostic=source.INVALID_DIAGNOSTIC,
@@ -628,6 +642,28 @@ build_static_value :: proc(checker: ^Checker, value: Ct_Value, span: source.Span
 	return invalid_hir_expr(checker, span, id, expected)
 }
 
+push_static_integer_binding :: proc(checker: ^Checker, name: symbol.Id, value_type: types.Type, value: i128) -> int {
+	start := len(checker.static_bindings)
+	if symbol.is_valid(name) && name != checker.sink_symbol {
+		id := ct_add_value(&checker.static_state, Ct_Value{kind=.Integer, type=value_type, integer=value})
+		append(&checker.static_bindings, Static_Binding{name=name, type=value_type, value=id})
+	}
+	return start
+}
+
+push_static_void_binding :: proc(checker: ^Checker, name: symbol.Id) -> int {
+	start := len(checker.static_bindings)
+	if symbol.is_valid(name) && name != checker.sink_symbol {
+		id := ct_add_value(&checker.static_state, Ct_Value{kind=.Void, type=types.VOID})
+		append(&checker.static_bindings, Static_Binding{name=name, type=types.VOID, value=id})
+	}
+	return start
+}
+
+pop_static_bindings :: proc(checker: ^Checker, start: int) {
+	resize(&checker.static_bindings, start)
+}
+
 comptime_string_argument :: proc(
 	checker: ^Checker,
 	id: ast.Expr_Id,
@@ -856,6 +892,104 @@ build_type_builtin :: proc(
 	)
 }
 
+tag_result_type :: proc(checker: ^Checker, value: types.Type) -> (types.Type, bool) {
+	if !types.is_tagged_union(value, &checker.module.types) {
+		return types.INVALID, false
+	}
+	return types.union_tag_enum(value, &checker.module.types), true
+}
+
+enum_member_name_from_value :: proc(checker: ^Checker, enum_type: types.Type, value: i128) -> (string, bool) {
+	if !types.is_enum(enum_type, &checker.module.types) {
+		return "", false
+	}
+	for member in types.enum_members_for(&checker.module.types, enum_type) {
+		if member.value == value {
+			return symbol_text(checker, symbol.Id(member.name)), true
+		}
+	}
+	return "", false
+}
+
+build_tag_intrinsic :: proc(
+	checker: ^Checker,
+	expr: ast.Expr,
+	locals: []Build_Local,
+	global_reads: ^[dynamic]hir.Global_Id,
+	calls: ^[dynamic]hir.Function_Id,
+	pkg: ast.Package_Id,
+	file: ast.File_Id,
+) -> hir.Expr_Id {
+	if len(expr.args) != 1 {
+		id := source.addf(checker.diagnostics, expr.span, "tag! expects 1 argument, got %d", len(expr.args))
+		return invalid_hir_expr(checker, expr.span, id)
+	}
+	state := ct_state_make(checker, pkg, file, values=checker.current_comptime_values, diagnose=false)
+	value_id, flow, comptime_ok := ct_eval_expr(&state, expr.args[0], types.INVALID, 0)
+	if comptime_ok && flow.kind == .Normal && value_id != INVALID_CT_VALUE && int(value_id) < len(state.values) {
+		value := state.values[value_id]
+		if tag_type, tagged := tag_result_type(checker, value.type); tagged && value.kind == .Struct &&
+		   value.active >= 0 {
+			fields := types.fields_for(&checker.module.types, value.type)
+			if int(value.active) < len(fields) {
+				if member, found := find_enum_member(checker, tag_type, symbol.Id(fields[value.active].name)); found {
+					ct_state_destroy(&state)
+					return add_hir_expr(checker, hir.Expr{
+						kind=.Integer, span=expr.span, type=tag_type, integer=i64(member.value),
+						target=hir.INVALID_REF, left=hir.INVALID_EXPR, right=hir.INVALID_EXPR,
+						diagnostic=source.INVALID_DIAGNOSTIC,
+					})
+				}
+			}
+		}
+	}
+	ct_state_destroy(&state)
+	value := build_nested_expr(checker, expr.args[0], locals, global_reads, calls, types.INVALID, pkg, file)
+	if checker.module.exprs[value].kind == .Invalid {
+		return value
+	}
+	tag_type, ok := tag_result_type(checker, checker.module.exprs[value].type)
+	if !ok {
+		id := source.add(checker.diagnostics, expr.span, "tag! requires a tagged-union value")
+		return invalid_hir_expr(checker, expr.span, id)
+	}
+	return add_hir_expr(checker, hir.Expr{
+		kind=.Union_Tag, span=expr.span, type=tag_type, left=value,
+		target=hir.INVALID_REF, right=hir.INVALID_EXPR, diagnostic=source.INVALID_DIAGNOSTIC,
+	})
+}
+
+build_tagname_intrinsic :: proc(
+	checker: ^Checker,
+	expr: ast.Expr,
+	pkg: ast.Package_Id,
+	file: ast.File_Id,
+) -> hir.Expr_Id {
+	if len(expr.args) != 1 {
+		id := source.addf(checker.diagnostics, expr.span, "tagname! expects 1 argument, got %d", len(expr.args))
+		return invalid_hir_expr(checker, expr.span, id)
+	}
+	state := ct_state_make(checker, pkg, file, values=checker.current_comptime_values, diagnose=false)
+	defer ct_state_destroy(&state)
+	value_id, flow, ok := ct_eval_expr(&state, expr.args[0], types.INVALID, 0)
+	if !ok || flow.kind != .Normal || value_id == INVALID_CT_VALUE || int(value_id) >= len(state.values) {
+		id := source.add(checker.diagnostics, expr.span, "tagname! requires a comptime-known enum value")
+		return invalid_hir_expr(checker, expr.span, id)
+	}
+	value := state.values[value_id]
+	name, name_ok := enum_member_name_from_value(checker, value.type, value.integer)
+	if value.kind != .Integer || !name_ok {
+		id := source.add(checker.diagnostics, expr.span, "tagname! requires a comptime-known enum value")
+		return invalid_hir_expr(checker, expr.span, id)
+	}
+	string_id := intern_comptime_string(checker, name)
+	return add_hir_expr(checker, hir.Expr{
+		kind=.String, span=expr.span, type=string_literal_type(checker, string_id), integer=i64(string_id),
+		target=hir.INVALID_REF, left=hir.INVALID_EXPR, right=hir.INVALID_EXPR,
+		diagnostic=source.INVALID_DIAGNOSTIC,
+	})
+}
+
 is_type_metatype_syntax :: proc(checker: ^Checker, value: ast.Type_Syntax) -> bool {
 	item, ok := types.node(&checker.module.types, value)
 	return ok && item.name == u32(checker.type_symbol) && item.qualifier == 0
@@ -2554,7 +2688,7 @@ clone_comptime_values :: proc(values: []Comptime_Value, allocator: mem.Allocator
 	return result
 }
 
-inline_expansions_equal :: proc(left, right: []Inline_Expansion) -> bool {
+expand_expansions_equal :: proc(left, right: []Expand_Expansion) -> bool {
 	if len(left) != len(right) {
 		return false
 	}
@@ -2574,7 +2708,7 @@ find_call_resolution :: proc(
 		entry := checker.call_resolutions[index]
 		if entry.expr == expr &&
 		   comptime_values_equal(entry.ctx, checker.current_comptime_values) &&
-		   inline_expansions_equal(entry.inline_ctx, checker.inline_context[:]) {
+		   expand_expansions_equal(entry.expand_ctx, checker.expand_context[:]) {
 			return index, true
 		}
 	}
@@ -2591,7 +2725,7 @@ store_call_resolution :: proc(
 	entry := Call_Resolution{
 		expr=expr,
 		ctx=clone_comptime_values(checker.current_comptime_values, checker.allocator),
-		inline_ctx=slice.clone(checker.inline_context[:], checker.allocator),
+		expand_ctx=slice.clone(checker.expand_context[:], checker.allocator),
 		mapping=slice.clone(mapping, checker.allocator),
 		comptime_values=clone_comptime_values(comptime_values, checker.allocator),
 		runtime_types=slice.clone(runtime_types, checker.allocator),
@@ -2599,7 +2733,7 @@ store_call_resolution :: proc(
 	if index, ok := find_call_resolution(checker, expr); ok {
 		previous := checker.call_resolutions[index]
 		delete(previous.ctx, checker.allocator)
-		delete(previous.inline_ctx, checker.allocator)
+		delete(previous.expand_ctx, checker.allocator)
 		delete(previous.mapping, checker.allocator)
 		delete(previous.comptime_values, checker.allocator)
 		delete(previous.runtime_types, checker.allocator)
@@ -4276,7 +4410,11 @@ infer_expr :: proc(
 		}
 		expr := checker.ast_module.exprs[frame.expr]
 		if frame.stage == 0 {
-			constant := eval_constant(checker, frame.expr)
+			constant := Constant{}
+			_, static_name := current_static_binding(checker, expr.name)
+			if expr.kind != .Name || symbol.is_valid(expr.qualifier) || !static_name {
+				constant = eval_constant(checker, frame.expr)
+			}
 			if constant.kind == .Overflow || constant.kind == .Div_By_Zero ||
 			   (constant.kind == .Value && !fits_i64(constant.value)) {
 				last = types.I64
@@ -4502,6 +4640,21 @@ infer_expr :: proc(
 					_ = pop(&stack)
 					continue
 				}
+				if is_intrinsic_call(checker, expr, "tag") {
+					if len(expr.args) == 1 {
+						value_type := infer_nested_expr(checker, expr.args[0], locals, pkg, file, demanded, local_types)
+						last, _ = tag_result_type(checker, value_type)
+					} else {
+						last = types.INVALID
+					}
+					_ = pop(&stack)
+					continue
+				}
+				if is_intrinsic_call(checker, expr, "tagname") {
+					last = types.slice(&checker.module.types, types.U8, false)
+					_ = pop(&stack)
+					continue
+				}
 				if is_ptrcast_call(checker, expr) {
 					if len(expr.args) != 2 {
 						last = types.INVALID
@@ -5087,21 +5240,21 @@ infer_statements :: proc(
 				infer_statements(checker, update[:], locals, local_types, pkg, file, demanded, result, result_hint)
 			}
 		case .For:
-			if statement.inline {
-				bindings, inline_error := inline_field_bindings(checker, statement.expr, statement.name, pkg, file)
-				if inline_error == .None {
-					for binding, inline_index in bindings {
-						binding_start := push_inline_binding(checker, binding, statement.index_name, inline_index, statement_id)
+			if statement.expand {
+				bindings, expand_error := expand_field_bindings(checker, statement.expr, statement.name, pkg, file)
+				if expand_error == .None {
+					for binding, expand_index in bindings {
+						binding_start := push_expand_binding(checker, binding, statement.index_name, expand_index, statement_id)
 						iteration: [dynamic]ast.Stmt_Id
 						iteration.allocator = checker.allocator
-						control := flatten_inline_iteration(
+						control := flatten_expand_iteration(
 							checker, statement.body, pkg, file, &iteration, statement.label, nil,
 						)
 						if control != .Invalid {
 							infer_statements(checker, iteration[:], locals, local_types, pkg, file, demanded, result, result_hint)
 						}
 						delete(iteration)
-						pop_inline_binding(checker, binding_start)
+						pop_expand_binding(checker, binding_start)
 						if control == .Break || control == .Invalid {
 							break
 						}
@@ -5164,13 +5317,65 @@ infer_statements :: proc(
 			// (e.g. `match get()`). Mirror the `.For`/unwrap-`.If` capture handling.
 			subject_type := infer_expr(checker, statement.expr, locals^[:], pkg, file, demanded, local_types)
 			is_tagged := types.is_tagged_union(subject_type, &checker.module.types)
+			is_enum_subject := types.is_enum(subject_type, &checker.module.types)
+			covered: [dynamic]symbol.Id
+			covered.allocator = checker.allocator
 			for arm_id in statement.body {
 				arm := checker.ast_module.statements[arm_id]
 				if arm.kind != .Match_Arm {
 					continue
 				}
+				if arm.expand && (is_tagged || is_enum_subject) {
+					tag_type := types.union_tag_enum(subject_type, &checker.module.types) if is_tagged else subject_type
+					if is_tagged {
+						for field in types.fields_for(&checker.module.types, subject_type) {
+							name := symbol.Id(field.name)
+							if contains_name(covered[:], name) {
+								continue
+							}
+							member, found := find_enum_member(checker, tag_type, name)
+							if !found {
+								continue
+							}
+							capture_start := len(locals^)
+							static_start := len(checker.static_bindings)
+							if len(arm.captures) > 1 {
+								_ = push_static_integer_binding(checker, arm.captures[1], tag_type, member.value)
+							}
+							if len(arm.captures) > 0 && arm.captures[0] != checker.sink_symbol {
+								if types.is_void(field.type) && !arm.pointer_capture {
+									_ = push_static_void_binding(checker, arm.captures[0])
+								} else {
+									capture_type := field.type
+									if arm.pointer_capture {
+										capture_type = types.pointer(&checker.module.types, field.type, true, false)
+									}
+									append(locals, Infer_Local{name=arm.captures[0], type=capture_type, declared=capture_type, statement=ast.INVALID_STMT})
+								}
+							}
+							infer_statements(checker, arm.body, locals, local_types, pkg, file, demanded, result, result_hint)
+							resize(locals, capture_start)
+							pop_static_bindings(checker, static_start)
+						}
+					} else {
+						for member in types.enum_members_for(&checker.module.types, subject_type) {
+							name := symbol.Id(member.name)
+							if contains_name(covered[:], name) {
+								continue
+							}
+							static_start := push_static_integer_binding(checker, arm.captures[0] if len(arm.captures) > 0 else symbol.INVALID, tag_type, member.value)
+							infer_statements(checker, arm.body, locals, local_types, pkg, file, demanded, result, result_hint)
+							pop_static_bindings(checker, static_start)
+						}
+					}
+					continue
+				}
 				for pattern in arm.patterns {
 					_ = infer_expr(checker, pattern, locals^[:], pkg, file, demanded, local_types)
+					pattern_expr := checker.ast_module.exprs[pattern]
+					if pattern_expr.kind == .Enum_Literal {
+						append(&covered, pattern_expr.name)
+					}
 				}
 				capture_start := len(locals^)
 				if len(arm.captures) > 0 && is_tagged && len(arm.patterns) > 0 {
@@ -5194,6 +5399,7 @@ infer_statements :: proc(
 				infer_statements(checker, arm.body, locals, local_types, pkg, file, demanded, result, result_hint)
 				resize(locals, capture_start)
 			}
+			delete(covered)
 		}
 	}
 	resize(locals, scope_start)
@@ -7592,7 +7798,11 @@ build_expr :: proc(
 		}
 		expr := checker.ast_module.exprs[frame.expr]
 		if frame.stage == 0 {
-			constant := eval_constant(checker, frame.expr)
+			constant := Constant{}
+			_, static_name := current_static_binding(checker, expr.name)
+			if expr.kind != .Name || symbol.is_valid(expr.qualifier) || !static_name {
+				constant = eval_constant(checker, frame.expr)
+			}
 			if constant.kind == .Value || constant.kind == .Overflow || constant.kind == .Div_By_Zero || constant.kind == .Non_Exact {
 				last = build_constant_expr(checker, expr, constant, frame.expected)
 				_ = pop(&stack)
@@ -7846,6 +8056,16 @@ build_expr :: proc(
 					_ = pop(&stack)
 					continue
 				}
+				if is_intrinsic_call(checker, expr, "tag") {
+					last = build_tag_intrinsic(checker, expr, locals, global_reads, calls, pkg, file)
+					_ = pop(&stack)
+					continue
+				}
+				if is_intrinsic_call(checker, expr, "tagname") {
+					last = build_tagname_intrinsic(checker, expr, pkg, file)
+					_ = pop(&stack)
+					continue
+				}
 				if is_ptrcast_call(checker, expr) {
 					if len(expr.args) != 2 {
 						id := source.addf(checker.diagnostics, expr.span, "ptrcast! expects 2 arguments, got %d", len(expr.args))
@@ -8642,6 +8862,9 @@ specialization_match_body :: proc(
 		return nil, {}, false, false
 	}
 	arm := checker.ast_module.statements[selection.arm]
+	if arm.expand {
+		return nil, {}, false, false
+	}
 	if arm.pointer_capture {
 		return nil, {}, false, false
 	}
@@ -8656,21 +8879,21 @@ specialization_match_body :: proc(
 	return arm.body, {}, false, true
 }
 
-Inline_Binding_Error :: enum u8 {
+Expand_Binding_Error :: enum u8 {
 	None,
 	Invalid,
 	Quota,
 	Diagnosed,
 }
 
-inline_field_bindings :: proc(
+expand_field_bindings :: proc(
 	checker: ^Checker,
 	expr: ast.Expr_Id,
 	capture: symbol.Id,
 	pkg: ast.Package_Id,
 	file: ast.File_Id,
 	diagnose := false,
-) -> ([]Static_Binding, Inline_Binding_Error) {
+) -> ([]Static_Binding, Expand_Binding_Error) {
 	state := ct_state_make(checker, pkg, file, values=checker.current_comptime_values, diagnose=diagnose)
 	defer ct_state_destroy(&state)
 	value_id, flow, ok := ct_eval_expr(&state, expr, types.INVALID, 0)
@@ -8680,7 +8903,7 @@ inline_field_bindings :: proc(
 	value := state.values[value_id]
 	if ct_value_contains_undefined(&state, value_id) {
 		if diagnose {
-			_ = ct_fail(&state, .Not_Comptime, checker.ast_module.exprs[expr].span, "inline for cannot expand an undefined comptime value")
+			_ = ct_fail(&state, .Not_Comptime, checker.ast_module.exprs[expr].span, "expand for cannot expand an undefined comptime value")
 		}
 		return nil, .Diagnosed if state.diagnostic != source.INVALID_DIAGNOSTIC else .Invalid
 	}
@@ -8748,7 +8971,7 @@ inline_field_bindings :: proc(
 	return bindings, .None
 }
 
-push_inline_binding :: proc(
+push_expand_binding :: proc(
 	checker: ^Checker,
 	binding: Static_Binding,
 	index_name: symbol.Id,
@@ -8757,7 +8980,7 @@ push_inline_binding :: proc(
 ) -> int {
 	start := len(checker.static_bindings)
 	append(&checker.static_bindings, binding)
-	append(&checker.inline_context, Inline_Expansion{statement=statement, index=u32(index)})
+	append(&checker.expand_context, Expand_Expansion{statement=statement, index=u32(index)})
 	if symbol.is_valid(index_name) {
 		value := ct_add_value(&checker.static_state, Ct_Value{kind=.Integer, type=types.USIZE, integer=i128(index)})
 		append(&checker.static_bindings, Static_Binding{name=index_name, type=types.USIZE, value=value})
@@ -8765,19 +8988,19 @@ push_inline_binding :: proc(
 	return start
 }
 
-pop_inline_binding :: proc(checker: ^Checker, start: int) {
+pop_expand_binding :: proc(checker: ^Checker, start: int) {
 	resize(&checker.static_bindings, start)
-	_ = pop(&checker.inline_context)
+	_ = pop(&checker.expand_context)
 }
 
-Inline_Control :: enum u8 {
+Expand_Control :: enum u8 {
 	Normal,
 	Break,
 	Continue,
 	Invalid,
 }
 
-inline_control_target :: proc(statement: ast.Stmt, target_label: symbol.Id, allow_unlabeled: bool) -> Inline_Control {
+expand_control_target :: proc(statement: ast.Stmt, target_label: symbol.Id, allow_unlabeled: bool) -> Expand_Control {
 	if statement.kind != .Break && statement.kind != .Continue {
 		return .Normal
 	}
@@ -8791,7 +9014,7 @@ inline_control_target :: proc(statement: ast.Stmt, target_label: symbol.Id, allo
 	return .Break if statement.kind == .Break else .Continue
 }
 
-contains_inline_control :: proc(
+contains_expand_control :: proc(
 	checker: ^Checker,
 	statements: []ast.Stmt_Id,
 	target_label: symbol.Id,
@@ -8799,32 +9022,32 @@ contains_inline_control :: proc(
 ) -> bool {
 	for statement_id in statements {
 		statement := checker.ast_module.statements[statement_id]
-		if inline_control_target(statement, target_label, allow_unlabeled) != .Normal {
+		if expand_control_target(statement, target_label, allow_unlabeled) != .Normal {
 			return true
 		}
 		#partial switch statement.kind {
 		case .Block:
-			if contains_inline_control(checker, statement.body, target_label, allow_unlabeled) {
+			if contains_expand_control(checker, statement.body, target_label, allow_unlabeled) {
 				return true
 			}
 		case .If:
-			if contains_inline_control(checker, statement.body, target_label, allow_unlabeled) ||
-			   contains_inline_control(checker, statement.else_body, target_label, allow_unlabeled) {
+			if contains_expand_control(checker, statement.body, target_label, allow_unlabeled) ||
+			   contains_expand_control(checker, statement.else_body, target_label, allow_unlabeled) {
 				return true
 			}
 		case .Match, .Match_Arm:
-			if contains_inline_control(checker, statement.body, target_label, allow_unlabeled) {
+			if contains_expand_control(checker, statement.body, target_label, allow_unlabeled) {
 				return true
 			}
 		case .For, .While:
 			// Unlabelled control belongs to the nested loop. A labelled jump can still
-			// name the surrounding inline loop and is therefore relevant here.
-			if contains_inline_control(checker, statement.body, target_label, false) {
+			// name the surrounding expand loop and is therefore relevant here.
+			if contains_expand_control(checker, statement.body, target_label, false) {
 				return true
 			}
 		case .Defer:
 			if statement.update != ast.INVALID_STMT &&
-			   contains_inline_control(checker, []ast.Stmt_Id{statement.update}, target_label, false) {
+			   contains_expand_control(checker, []ast.Stmt_Id{statement.update}, target_label, false) {
 				return true
 			}
 		}
@@ -8861,7 +9084,7 @@ clone_statement_body :: proc(checker: ^Checker, statement: ast.Stmt, body: []ast
 	return id
 }
 
-append_inline_block :: proc(checker: ^Checker, span: source.Span, body: []ast.Stmt_Id, out: ^[dynamic]ast.Stmt_Id) {
+append_expand_block :: proc(checker: ^Checker, span: source.Span, body: []ast.Stmt_Id, out: ^[dynamic]ast.Stmt_Id) {
 	if len(body) == 0 {
 		return
 	}
@@ -8891,7 +9114,7 @@ same_stmt_ids :: proc(left, right: []ast.Stmt_Id) -> bool {
 	return true
 }
 
-flatten_inline_iteration :: proc(
+flatten_expand_iteration :: proc(
 	checker: ^Checker,
 	statements: []ast.Stmt_Id,
 	pkg: ast.Package_Id,
@@ -8899,10 +9122,10 @@ flatten_inline_iteration :: proc(
 	out: ^[dynamic]ast.Stmt_Id,
 	target_label: symbol.Id,
 	diagnostic: ^source.Diagnostic_Id,
-) -> Inline_Control {
+) -> Expand_Control {
 	for statement_id in statements {
 		statement := checker.ast_module.statements[statement_id]
-		if control := inline_control_target(statement, target_label, true); control != .Normal {
+		if control := expand_control_target(statement, target_label, true); control != .Normal {
 			return control
 		}
 		if statement.kind == .If && len(statement.captures) == 0 {
@@ -8910,20 +9133,20 @@ flatten_inline_iteration :: proc(
 				selected_body := statement.body if selected else statement.else_body
 				branch: [dynamic]ast.Stmt_Id
 				branch.allocator = checker.allocator
-				flow := flatten_inline_iteration(checker, selected_body, pkg, file, &branch, target_label, diagnostic)
-				append_inline_block(checker, statement.span, branch[:], out)
+				flow := flatten_expand_iteration(checker, selected_body, pkg, file, &branch, target_label, diagnostic)
+				append_expand_block(checker, statement.span, branch[:], out)
 				delete(branch)
 				if flow != .Normal {
 					return flow
 				}
 				continue
 			}
-			if contains_inline_control(checker, statement.body, target_label, true) ||
-			   contains_inline_control(checker, statement.else_body, target_label, true) {
+			if contains_expand_control(checker, statement.body, target_label, true) ||
+			   contains_expand_control(checker, statement.else_body, target_label, true) {
 				if diagnostic != nil {
 					diagnostic^ = source.add(
 						checker.diagnostics, statement.span,
-						"break or continue targeting an inline loop must be compile-time-resolvable",
+						"break or continue targeting an expand loop must be compile-time-resolvable",
 					)
 				}
 				return .Invalid
@@ -8933,7 +9156,7 @@ flatten_inline_iteration :: proc(
 			if selected_body, _, _, comptime_ok := specialization_match_body(checker, statement, pkg, file); comptime_ok {
 				selected: [dynamic]ast.Stmt_Id
 				selected.allocator = checker.allocator
-				flow := flatten_inline_iteration(checker, selected_body, pkg, file, &selected, target_label, diagnostic)
+				flow := flatten_expand_iteration(checker, selected_body, pkg, file, &selected, target_label, diagnostic)
 				if flow != .Normal {
 					arm_index := -1
 					for arm_id, index in statement.body {
@@ -8958,11 +9181,11 @@ flatten_inline_iteration :: proc(
 				append(out, statement_id)
 				continue
 			}
-			if contains_inline_control(checker, statement.body, target_label, true) {
+			if contains_expand_control(checker, statement.body, target_label, true) {
 				if diagnostic != nil {
 					diagnostic^ = source.add(
 						checker.diagnostics, statement.span,
-						"break or continue targeting an inline loop must be compile-time-resolvable",
+						"break or continue targeting an expand loop must be compile-time-resolvable",
 					)
 				}
 				return .Invalid
@@ -8971,11 +9194,11 @@ flatten_inline_iteration :: proc(
 		if statement.kind == .Block {
 			block: [dynamic]ast.Stmt_Id
 			block.allocator = checker.allocator
-			flow := flatten_inline_iteration(checker, statement.body, pkg, file, &block, target_label, diagnostic)
+			flow := flatten_expand_iteration(checker, statement.body, pkg, file, &block, target_label, diagnostic)
 			if flow == .Normal {
 				append(out, statement_id)
 			} else {
-				append_inline_block(checker, statement.span, block[:], out)
+				append_expand_block(checker, statement.span, block[:], out)
 			}
 			delete(block)
 			if flow != .Normal {
@@ -8984,11 +9207,11 @@ flatten_inline_iteration :: proc(
 			continue
 		}
 		if (statement.kind == .For || statement.kind == .While || statement.kind == .Defer) &&
-		   contains_inline_control(checker, []ast.Stmt_Id{statement_id}, target_label, false) {
+		   contains_expand_control(checker, []ast.Stmt_Id{statement_id}, target_label, false) {
 			if diagnostic != nil {
 				diagnostic^ = source.add(
 					checker.diagnostics, statement.span,
-					"break or continue targeting an inline loop must be compile-time-resolvable",
+					"break or continue targeting an expand loop must be compile-time-resolvable",
 				)
 			}
 			return .Invalid
@@ -9821,19 +10044,19 @@ build_block :: proc(
 			})
 			ctx.problematic^ = ctx.problematic^ || checker.module.exprs[condition].kind == .Invalid
 		case .For:
-			if statement.inline {
+			if statement.expand {
 				if statement.pointer_capture {
-					id := source.add(checker.diagnostics, statement.span, "inline for does not support pointer captures")
+					id := source.add(checker.diagnostics, statement.span, "expand for does not support pointer captures")
 					append(&body, hir.stmt_id(len(checker.module.statements)))
 					append(&checker.module.statements, hir.Stmt{kind=.Trap, span=statement.span, diagnostic=id})
 					ctx.problematic^ = true
 					continue
 				}
-				bindings, inline_error := inline_field_bindings(checker, statement.expr, statement.name, ctx.pkg, ctx.file, true)
-				if inline_error != .None && inline_error != .Diagnosed {
-					message := "inline for requires a comptime tuple, fixed array, range, slice, or reflection value"
-					if inline_error == .Quota {
-						message = "inline for expansion exceeds the compile-time evaluation quota"
+				bindings, expand_error := expand_field_bindings(checker, statement.expr, statement.name, ctx.pkg, ctx.file, true)
+				if expand_error != .None && expand_error != .Diagnosed {
+					message := "expand for requires a comptime tuple, fixed array, range, slice, or reflection value"
+					if expand_error == .Quota {
+						message = "expand for expansion exceeds the compile-time evaluation quota"
 					}
 					id := source.add(
 						checker.diagnostics, statement.span,
@@ -9842,13 +10065,13 @@ build_block :: proc(
 					append(&body, hir.stmt_id(len(checker.module.statements)))
 					append(&checker.module.statements, hir.Stmt{kind=.Trap, span=statement.span, diagnostic=id})
 					ctx.problematic^ = true
-				} else if inline_error == .None {
-					for binding, inline_index in bindings {
-						binding_start := push_inline_binding(checker, binding, statement.index_name, inline_index, statement_id)
+				} else if expand_error == .None {
+					for binding, expand_index in bindings {
+						binding_start := push_expand_binding(checker, binding, statement.index_name, expand_index, statement_id)
 						iteration: [dynamic]ast.Stmt_Id
 						iteration.allocator = checker.allocator
 						diagnostic := source.INVALID_DIAGNOSTIC
-						control := flatten_inline_iteration(
+						control := flatten_expand_iteration(
 							checker, statement.body, ctx.pkg, ctx.file, &iteration, statement.label, &diagnostic,
 						)
 						if control == .Invalid {
@@ -9863,7 +10086,7 @@ build_block :: proc(
 							delete(expanded, checker.allocator)
 						}
 						delete(iteration)
-						pop_inline_binding(checker, binding_start)
+						pop_expand_binding(checker, binding_start)
 						if control == .Break || control == .Invalid {
 							break
 						}
@@ -10846,6 +11069,7 @@ emit_match :: proc(
 	covered.allocator = checker.allocator
 	defer delete(covered)
 	has_else := false
+	has_expand := false
 
 	for arm_id in statement.body {
 		arm := checker.ast_module.statements[arm_id]
@@ -10853,10 +11077,107 @@ emit_match :: proc(
 			ok = false
 			continue
 		}
-		if has_else {
-			source.add(checker.diagnostics, arm.span, "arms after 'else' are unreachable")
+		if has_else || has_expand {
+			message := "arms after 'else' are unreachable" if has_else else "arms after 'expand' are unreachable"
+			source.add(checker.diagnostics, arm.span, message)
 			ok = false
 		}
+		if arm.expand {
+			if !is_tagged && !is_enum_subject {
+				source.add(checker.diagnostics, arm.span, "'expand' requires an enum or tagged-union match subject")
+				ok = false
+				continue
+			}
+			expected_captures := 1 if is_enum_subject else 2
+			if len(arm.captures) == 0 || len(arm.captures) > expected_captures {
+				description := "exactly one capture" if is_enum_subject else "one or two captures"
+				source.addf(checker.diagnostics, arm.span, "expanded match on '%s' requires %s", type_label(checker, subject_type), description)
+				ok = false
+			}
+			if is_enum_subject && arm.pointer_capture {
+				source.add(checker.diagnostics, arm.span, "enum expansion does not support pointer captures")
+				ok = false
+			}
+			if len(arm.captures) > 1 && arm.captures[0] != checker.sink_symbol && arm.captures[0] == arm.captures[1] {
+				source.add(checker.diagnostics, arm.span, "expand captures must have distinct names")
+				ok = false
+			}
+			remaining := 0
+			member_enum := tag_enum if is_tagged else subject_type
+			if is_tagged {
+				for field, field_index in types.fields_for(store, subject_type) {
+					name := symbol.Id(field.name)
+					if contains_name(covered[:], name) {
+						continue
+					}
+					member, found := find_enum_member(checker, member_enum, name)
+					if !found {
+						ok = false
+						continue
+					}
+					remaining += 1
+					append(&covered, name)
+					member_expr := enum_member_hir(checker, member_enum, name, arm.span)
+					condition := add_hir_expr(checker, hir.Expr{
+						kind=.Eq, span=arm.span, type=types.BOOL,
+						left=slot_read(checker, key_local, key_type, arm.span), right=member_expr,
+						target=hir.INVALID_REF, diagnostic=source.INVALID_DIAGNOSTIC,
+					})
+					static_start := len(checker.static_bindings)
+					if len(arm.captures) > 1 {
+						_ = push_static_integer_binding(checker, arm.captures[1], member_enum, member.value)
+					}
+					body_arm := arm
+					if types.is_void(field.type) && !arm.pointer_capture {
+						if len(arm.captures) > 0 {
+							_ = push_static_void_binding(checker, arm.captures[0])
+						}
+						body_arm.captures = nil
+					}
+					arm_body, body_ok := build_match_arm_body(
+						ctx, body_arm, subject_type, subj_local, subj_is_pointer, ptr_type, subj_writable,
+						field_index, field.type, as_value, slot, slot_type, span,
+					)
+					pop_static_bindings(checker, static_start)
+					ok = body_ok && ok
+					append(&built, Match_Built_Arm{condition=condition, body=arm_body})
+				}
+			} else {
+				for member in types.enum_members_for(store, subject_type) {
+					name := symbol.Id(member.name)
+					if contains_name(covered[:], name) {
+						continue
+					}
+					remaining += 1
+					append(&covered, name)
+					member_expr := enum_member_hir(checker, subject_type, name, arm.span)
+					condition := add_hir_expr(checker, hir.Expr{
+						kind=.Eq, span=arm.span, type=types.BOOL,
+						left=slot_read(checker, key_local, key_type, arm.span), right=member_expr,
+						target=hir.INVALID_REF, diagnostic=source.INVALID_DIAGNOSTIC,
+					})
+					static_start := push_static_integer_binding(
+						checker, arm.captures[0] if len(arm.captures) > 0 else symbol.INVALID,
+						subject_type, member.value,
+					)
+					body_arm := arm
+					body_arm.captures = nil
+					arm_body, body_ok := build_match_arm_body(
+						ctx, body_arm, subject_type, subj_local, subj_is_pointer, ptr_type, subj_writable,
+						-1, types.INVALID, as_value, slot, slot_type, span,
+					)
+					pop_static_bindings(checker, static_start)
+					ok = body_ok && ok
+					append(&built, Match_Built_Arm{condition=condition, body=arm_body})
+				}
+			}
+			if remaining == 0 {
+				source.add(checker.diagnostics, arm.span, "redundant 'expand': the 'match' already covers every variant")
+				ok = false
+			}
+			has_expand = true
+			continue
+		}
 		is_else := len(arm.patterns) == 0
 		condition := hir.INVALID_EXPR
 		field_index := -1
@@ -11214,7 +11535,20 @@ build_value_match :: proc(
 	}
 	subtree: [dynamic]hir.Stmt_Id
 	subtree.allocator = checker.allocator
-	ok := emit_match(ctx, &subtree, statement, true, &slot, &slot_type)
+	ok := false
+	if selected_body, capture, has_capture, comptime_ok := specialization_match_body(
+		checker, statement, ctx.pkg, ctx.file,
+	); comptime_ok {
+		if has_capture {
+			append(&checker.static_bindings, capture)
+		}
+		ok = build_value_arm(ctx, &subtree, selected_body, &slot, &slot_type, span)
+		if has_capture {
+			_ = pop(&checker.static_bindings)
+		}
+	} else {
+		ok = emit_match(ctx, &subtree, statement, true, &slot, &slot_type)
+	}
 	if !ok || slot == hir.INVALID_LOCAL {
 		for s in subtree {
 			append(body, s)
@@ -12391,7 +12725,7 @@ check :: proc(
 	checker.static_bindings.allocator = allocator
 	checker.comptime_keys.allocator = allocator
 	checker.comptime_static_values.allocator = allocator
-	checker.inline_context.allocator = allocator
+	checker.expand_context.allocator = allocator
 	checker.static_state = ct_state_make(&checker, 0, ast.INVALID_FILE)
 	build_symbol_indexes(&checker)
 	checker.global_types = make([]types.Type, len(ast_module.globals), allocator)
@@ -12467,7 +12801,7 @@ check :: proc(
 		}
 		for resolution in checker.call_resolutions {
 			delete(resolution.ctx, allocator)
-			delete(resolution.inline_ctx, allocator)
+			delete(resolution.expand_ctx, allocator)
 			delete(resolution.mapping, allocator)
 			delete(resolution.comptime_values, allocator)
 			delete(resolution.runtime_types, allocator)
@@ -12483,7 +12817,7 @@ check :: proc(
 		}
 		delete(checker.comptime_keys)
 		delete(checker.comptime_static_values)
-		delete(checker.inline_context)
+		delete(checker.expand_context)
 	}
 
 	for function, index in ast_module.functions {

compiler/checker/comptime.odin

@@ -2515,6 +2515,50 @@ ct_eval_call_expr :: proc(state: ^Ct_State, expr: ast.Expr, expected: types.Type
 		}
 		return ct_typeinfo_value(state, target, expr.span)
 	}
+	if is_intrinsic_call(checker, expr, "tag") {
+		if len(expr.args) != 1 {
+			return INVALID_CT_VALUE, ct_flow(.Normal), ct_failf(state, .Not_Comptime, expr.span, "tag! expects 1 argument, got %d", len(expr.args))
+		}
+		value_id, flow, ok := ct_eval_expr(state, expr.args[0], types.INVALID, depth+1)
+		if !ok || flow.kind != .Normal {
+			return INVALID_CT_VALUE, flow, ok
+		}
+		if value_id == INVALID_CT_VALUE || int(value_id) >= len(state.values) {
+			return INVALID_CT_VALUE, ct_flow(.Normal), false
+		}
+		value := state.values[value_id]
+		tag_type, tag_ok := tag_result_type(checker, value.type)
+		if !tag_ok || value.kind != .Struct || value.active < 0 {
+			return INVALID_CT_VALUE, ct_flow(.Normal), ct_fail(state, .Not_Comptime, expr.span, "tag! requires a tagged-union value")
+		}
+		fields := types.fields_for(&checker.module.types, value.type)
+		if int(value.active) >= len(fields) {
+			return INVALID_CT_VALUE, ct_flow(.Normal), false
+		}
+		member, found := find_enum_member(checker, tag_type, symbol.Id(fields[value.active].name))
+		if !found {
+			return INVALID_CT_VALUE, ct_flow(.Normal), false
+		}
+		return ct_add_value(state, Ct_Value{kind=.Integer, type=tag_type, integer=member.value}), ct_flow(.Normal), true
+	}
+	if is_intrinsic_call(checker, expr, "tagname") {
+		if len(expr.args) != 1 {
+			return INVALID_CT_VALUE, ct_flow(.Normal), ct_failf(state, .Not_Comptime, expr.span, "tagname! expects 1 argument, got %d", len(expr.args))
+		}
+		value_id, flow, ok := ct_eval_expr(state, expr.args[0], types.INVALID, depth+1)
+		if !ok || flow.kind != .Normal {
+			return INVALID_CT_VALUE, flow, ok
+		}
+		if value_id == INVALID_CT_VALUE || int(value_id) >= len(state.values) {
+			return INVALID_CT_VALUE, ct_flow(.Normal), false
+		}
+		value := state.values[value_id]
+		name, found := enum_member_name_from_value(checker, value.type, value.integer)
+		if value.kind != .Integer || !found {
+			return INVALID_CT_VALUE, ct_flow(.Normal), ct_fail(state, .Not_Comptime, expr.span, "tagname! requires a comptime-known enum value")
+		}
+		return ct_reflection_string(state, name), ct_flow(.Normal), true
+	}
 	if builtin := type_builtin_call(checker, expr); builtin != .None {
 		if len(expr.args) != 1 {
 			return INVALID_CT_VALUE, ct_flow(.Normal), ct_failf(state, .Not_Comptime, expr.span, "%s! expects 1 argument, got %d", symbol_text(checker, expr.name), len(expr.args))
@@ -3660,6 +3704,7 @@ ct_exec_for :: proc(state: ^Ct_State, statement: ast.Stmt, yield_returns: bool,
 Ct_Match_Selection :: struct {
 	arm:           ast.Stmt_Id,
 	payload:       Ct_Value_Id,
+	tag:           Ct_Value_Id,
 	payload_field: int,
 	payload_type:  types.Type,
 }
@@ -3684,9 +3729,40 @@ ct_select_match_arm :: proc(
 		selection := Ct_Match_Selection{
 			arm=arm_id,
 			payload=INVALID_CT_VALUE,
+			tag=INVALID_CT_VALUE,
 			payload_field=-1,
 			payload_type=types.INVALID,
 		}
+		if arm.expand {
+			if subject_value.kind == .Struct && types.is_tagged_union(subject_value.type, &checker.module.types) {
+				fields := types.fields_for(&checker.module.types, subject_value.type)
+				if subject_value.active < 0 || int(subject_value.active) >= len(fields) {
+					return {}, false
+				}
+				field_index := int(subject_value.active)
+				field := fields[field_index]
+				selection.payload_field = field_index
+				selection.payload_type = field.type
+				children := ct_child_slice(state, subject_value)
+				if len(children) > 0 {
+					selection.payload = children[0]
+				} else if types.is_void(field.type) {
+					selection.payload = ct_add_value(state, Ct_Value{kind=.Void, type=types.VOID})
+				}
+				tag_type := types.union_tag_enum(subject_value.type, &checker.module.types)
+				member, found := find_enum_member(checker, tag_type, symbol.Id(field.name))
+				if !found {
+					return {}, false
+				}
+				selection.tag = ct_add_value(state, Ct_Value{kind=.Integer, type=tag_type, integer=member.value})
+				return selection, true
+			}
+			if subject_value.kind == .Integer && types.is_enum(subject_value.type, &checker.module.types) {
+				selection.tag = subject
+				return selection, true
+			}
+			return {}, false
+		}
 		if !matched {
 			for pattern_id in arm.patterns {
 				pattern := checker.ast_module.exprs[pattern_id]
@@ -3765,7 +3841,11 @@ ct_exec_match :: proc(state: ^Ct_State, statement: ast.Stmt, yield_returns: bool
 	if selected {
 		arm := checker.ast_module.statements[selection.arm]
 		scope_start := len(state.bindings)
-		if len(arm.captures) > 0 && selection.payload != INVALID_CT_VALUE {
+		if arm.expand && types.is_enum(state.values[subject].type, &checker.module.types) {
+			if len(arm.captures) > 0 && arm.captures[0] != checker.sink_symbol {
+				ct_bind_value(state, arm.captures[0], state.values[subject].type, subject, false)
+			}
+		} else if len(arm.captures) > 0 && selection.payload != INVALID_CT_VALUE {
 			capture := arm.captures[0]
 			if arm.pointer_capture {
 				if subject_place == INVALID_CT_PLACE || selection.payload_field < 0 || !types.is_valid(selection.payload_type) {
@@ -3785,6 +3865,10 @@ ct_exec_match :: proc(state: ^Ct_State, statement: ast.Stmt, yield_returns: bool
 				ct_bind_value(state, capture, state.values[selection.payload].type, selection.payload, false)
 			}
 		}
+		if arm.expand && len(arm.captures) > 1 && arm.captures[1] != checker.sink_symbol &&
+		   selection.tag != INVALID_CT_VALUE {
+			ct_bind_value(state, arm.captures[1], state.values[selection.tag].type, selection.tag, false)
+		}
 		if yield_returns && len(arm.body) == 1 && checker.ast_module.statements[arm.body[0]].kind == .Expression {
 			expr_stmt := checker.ast_module.statements[arm.body[0]]
 			value, expr_flow, expr_ok := ct_eval_expr(state, expr_stmt.expr, types.INVALID, depth+1)

compiler/hir/hir.odin

@@ -74,6 +74,7 @@ Linkage :: enum u8 {
 
 Expr_Kind :: enum u8 {
 	Invalid,
+	Void,
 	Integer,
 	Float,
 	String,

compiler/lexer/lexer.odin

@@ -37,6 +37,7 @@ keyword_kind :: proc(text: string) -> token.Kind {
 	case "if":            return .Keyword_If
 	case "while":         return .Keyword_While
 	case "for":           return .Keyword_For
+	case "expand":        return .Keyword_Expand
 	case "break":         return .Keyword_Break
 	case "continue":      return .Keyword_Continue
 	case "defer":         return .Keyword_Defer

compiler/llvm/llvm.odin

@@ -1103,7 +1103,9 @@ emit_instruction_stream :: proc(
 			fmt.sbprintf(
 				&emitter.builder,
 				"  %%v%d = getelementptr %s, ptr %%v%d, i64 0\n",
-				instruction_index, llvm_type(child, &emitter.module.types), instruction.a,
+				instruction_index,
+				"i8" if types.is_void(child) else llvm_type(child, &emitter.module.types),
+				instruction.a,
 			)
 		case .Alloca:
 			if !types.is_runtime_value(instruction.type, &emitter.module.types) {

compiler/lower/lower.odin

@@ -659,6 +659,13 @@ lower_expr :: proc(state: ^State, expr_id: hir.Expr_Id) -> ir.Instruction_Id {
 			case .Invalid:
 				last = append_recovery_value(state, expr.span, expr.type, expr.diagnostic)
 				_ = pop(&stack)
+			case .Void:
+				last = append_instruction(state, ir.Instruction{
+					op=.Const, span=expr.span, type=types.VOID,
+					target=ir.INVALID_REF, a=ir.INVALID_INSTRUCTION, b=ir.INVALID_INSTRUCTION,
+					diagnostic=source.INVALID_DIAGNOSTIC,
+				})
+				_ = pop(&stack)
 			case .Integer, .Float, .Bool:
 				last = append_instruction(state, ir.Instruction{
 					op=.Const, span=expr.span, type=expr.type, integer=expr.integer,

compiler/parser/parser.odin

@@ -1680,7 +1680,15 @@ parse_statement :: proc(parser: ^Parser) -> ast.Stmt_Id {
 	   peek(parser).kind == .Keyword_For {
 		start := advance(parser)
 		id := parse_for(parser)
-		parser.module.statements[id].inline = true
+		parser.module.statements[id].expand = true
+		parser.module.statements[id].span = span_from(start.span, parser.module.statements[id].span)
+		source.add(parser.diagnostics, start.span, "'inline for' was renamed to 'expand for'")
+		return id
+	}
+	if current(parser).kind == .Keyword_Expand && peek(parser).kind == .Keyword_For {
+		start := advance(parser)
+		id := parse_for(parser)
+		parser.module.statements[id].expand = true
 		parser.module.statements[id].span = span_from(start.span, parser.module.statements[id].span)
 		return id
 	}
@@ -2104,10 +2112,8 @@ parse_arm_body :: proc(parser: ^Parser) -> []ast.Stmt_Id {
 	return single
 }
 
-// parse_match_arm parses one `<pattern,...> [|[@]capture|]: <body>` arm (or
-// `else: <body>`). `patterns` is empty for `else`, one expr for a single pattern, or
-// several for a multi-pattern arm; `captures` holds the optional 0-or-1 payload capture
-// name with `pointer_capture` set for the `|@cap|` form (validated in the checker).
+// parse_match_arm parses one `<pattern,...> [|[@]capture|]: <body>`, `else: <body>`,
+// or `expand |[@]value[, tag]|: <body>` arm.
 parse_match_arm :: proc(parser: ^Parser) -> ast.Stmt_Id {
 	start := current(parser).span
 	patterns: [dynamic]ast.Expr_Id
@@ -2115,7 +2121,43 @@ parse_match_arm :: proc(parser: ^Parser) -> ast.Stmt_Id {
 	captures: [dynamic]symbol.Id
 	captures.allocator = parser.module.allocator
 	pointer_capture := false
-	if _, is_else := allow(parser, .Keyword_Else); !is_else {
+	expand := false
+	if _, is_expand := allow(parser, .Keyword_Expand); is_expand {
+		expand = true
+		if _, ok := allow(parser, .Pipe); !ok {
+			source.add(parser.diagnostics, current(parser).span, "expected '|' before expand captures")
+		} else {
+			if _, at_ok := allow(parser, .At); at_ok {
+				pointer_capture = true
+			}
+			name_tok := current(parser)
+			if name_tok.kind == .Identifier || name_tok.kind == .Underscore {
+				advance(parser)
+				append(&captures, name_tok.symbol)
+			} else {
+				source.add(parser.diagnostics, current(parser).span, "expected an expand value capture")
+			}
+			if _, comma_ok := allow(parser, .Comma); comma_ok {
+				tag_tok := current(parser)
+				if tag_tok.kind == .Identifier || tag_tok.kind == .Underscore {
+					advance(parser)
+					append(&captures, tag_tok.symbol)
+				} else {
+					source.add(parser.diagnostics, current(parser).span, "expected an expand tag capture")
+				}
+				if _, extra := allow(parser, .Comma); extra {
+					source.add(parser.diagnostics, current(parser).span, "'expand' accepts at most two captures")
+					for current(parser).kind != .Pipe && current(parser).kind != .Colon &&
+					    current(parser).kind != .Newline && current(parser).kind != .Eof {
+						advance(parser)
+					}
+				}
+			}
+			if _, close_ok := allow(parser, .Pipe); !close_ok {
+				source.add(parser.diagnostics, current(parser).span, "expected '|' to close expand captures")
+			}
+		}
+	} else if _, is_else := allow(parser, .Keyword_Else); !is_else {
 		saved := parser.no_struct_literal
 		parser.no_struct_literal = true
 		append(&patterns, parse_expression(parser))
@@ -2155,6 +2197,7 @@ parse_match_arm :: proc(parser: ^Parser) -> ast.Stmt_Id {
 		patterns=patterns[:],
 		captures=captures[:],
 		pointer_capture=pointer_capture,
+		expand=expand,
 		body=body,
 		target=ast.INVALID_EXPR,
 		update=ast.INVALID_STMT,

compiler/token/token.odin

@@ -73,6 +73,7 @@ Kind :: enum u8 {
 	Keyword_If,
 	Keyword_While,
 	Keyword_For,
+	Keyword_Expand,
 	Keyword_Break,
 	Keyword_Continue,
 	Keyword_Defer,