let process_enum_values values =

let rec process_values acc current_value = function

| [] -> List.rev acc

| (const_name, None) :: rest ->

(* Auto-assign current value *)

let processed_value = (const_name, Some (Signed64 (Int64.of_int current_value))) in

process_values (processed_value :: acc) (current_value + 1) rest

| (const_name, Some explicit_value) :: rest ->

(* Use explicit value and update current value *)

let processed_value = (const_name, Some explicit_value) in

let explicit_int = Int64.to_int (IntegerValue.to_int64 explicit_value) in

process_values (processed_value :: acc) (explicit_int + 1) rest

in

process_values [] 0 values

in

(* Test case 1: All auto-assigned values *)

let values1 = [("TCP", None); ("UDP", None); ("ICMP", None)] in

let result1 = process_enum_values values1 in

let expected1 = [("TCP", Some 0); ("UDP", Some 1); ("ICMP", Some 2)] in

check (list (pair string (option int))) "auto assignment" expected1 (List.map (fun (name, opt) -> (name, Option.map (fun v -> Int64.to_int (IntegerValue.to_int64 v)) opt)) result1);

(* Test case 2: Mixed explicit and auto values *)

let values2 = [("TCP", Some (Signed64 6L)); ("UDP", Some (Signed64 17L)); ("ICMP", None); ("UNKNOWN", None)] in

let result2 = process_enum_values values2 in

let expected2 = [("TCP", Some 6); ("UDP", Some 17); ("ICMP", Some 18); ("UNKNOWN", Some 19)] in

check (list (pair string (option int))) "mixed assignment" expected2 (List.map (fun (name, opt) -> (name, Option.map (fun v -> Int64.to_int (IntegerValue.to_int64 v)) opt)) result2);

(* Test case 3: Auto values with explicit override *)

let values3 = [("FIRST", None); ("SECOND", Some (Signed64 10L)); ("THIRD", None)] in

let result3 = process_enum_values values3 in

let expected3 = [("FIRST", Some 0); ("SECOND", Some 10); ("THIRD", Some 11)] in

let symbol_table = create_symbol_table () in

(* Create enum definition *)

let enum_values = [("XDP_ABORTED", Some (Signed64 0L)); ("XDP_DROP", Some (Signed64 1L)); ("XDP_PASS", Some (Signed64 2L))] in

let enum_def = EnumDef ("xdp_action", enum_values, { line = 1; column = 1; filename = "test" }) in

(* Add to symbol table *)

add_type_def symbol_table enum_def;

(* Verify enum type is registered *)

let enum_symbol = lookup_symbol symbol_table "xdp_action" in

check bool "enum type found" true (enum_symbol <> None);

(match enum_symbol with

| Some symbol ->

(match symbol.kind with

| TypeDef (EnumDef (name, values, _)) ->

check string "enum name" "xdp_action" name;

check int "enum value count" 3 (List.length values)

| _ -> check bool "wrong symbol kind" false true)

| None -> check bool "enum symbol not found" false true);

(* Verify enum constants are registered *)

let const1 = lookup_symbol symbol_table "XDP_ABORTED" in

let const2 = lookup_symbol symbol_table "XDP_DROP" in

let const3 = lookup_symbol symbol_table "XDP_PASS" in

check bool "enum constant 1 found" true (const1 <> None);

check bool "enum constant 2 found" true (const2 <> None);

let empty_symbol_table = Kernelscript.Symbol_table.create_symbol_table () in

(* Add enum type to context *)

let enum_values = [("XDP_PASS", Some (Signed64 2L)); ("XDP_DROP", Some (Signed64 1L))] in

let enum_def = EnumDef ("xdp_action", enum_values, { line = 1; column = 1; filename = "test" }) in

let enum_type = Enum "xdp_action" in

let ctx = create_context empty_symbol_table [] in (* Provide empty AST for tests *)

Hashtbl.replace ctx.types "xdp_action" enum_def;

(* Test enum-integer unification *)

let unify_result1 = unify_types enum_type U32 in

check bool "enum unifies with u32" true (unify_result1 = Some U32);

let unify_result2 = unify_types U32 enum_type in

check bool "u32 unifies with enum" true (unify_result2 = Some U32);

(* Test enum-enum unification *)

let same_enum = Enum "xdp_action" in

let unify_result3 = unify_types enum_type same_enum in

check bool "enum unifies with same enum" true (unify_result3 = Some enum_type);

let different_enum = Enum "TcAction" in

let unify_result4 = unify_types enum_type different_enum in

check bool "enum doesn't unify with different enum" true (unify_result4 = None);

(* Test enum with non-integer types *)

let unify_result5 = unify_types enum_type Bool in

let symbol_table = create_symbol_table () in

(* Add enum with constants *)

let enum_values = [("PROTOCOL_TCP", Some (Signed64 6L)); ("PROTOCOL_UDP", Some (Signed64 17L)); ("PROTOCOL_ICMP", Some (Signed64 1L))] in

let enum_def = EnumDef ("Protocol", enum_values, { line = 1; column = 1; filename = "test" }) in

add_type_def symbol_table enum_def;

(* Test constant lookup *)

let tcp_const = lookup_symbol symbol_table "PROTOCOL_TCP" in

check bool "TCP constant found" true (tcp_const <> None);

(match tcp_const with

| Some symbol ->

(match symbol.kind with

| EnumConstant (enum_name, Some value) ->

check string "constant enum name" "Protocol" enum_name;

check int "TCP value" 6 (Int64.to_int (IntegerValue.to_int64 value))

| _ -> check bool "wrong constant kind" false true)

| None -> check bool "TCP constant not found" false true);

(* Test invalid constant lookup *)

let invalid_const = lookup_symbol symbol_table "INVALID" in

(* Test enum definition generation for eBPF C *)

let enum_name = "xdp_action" in

let enum_values = [("XDP_ABORTED", 0); ("XDP_DROP", 1); ("XDP_PASS", 2); ("XDP_TX", 3)] in

(* Simulate code generation *)

let generate_enum_c enum_name values =

let header = Printf.sprintf "enum %s {" enum_name in

let constants = List.mapi (fun i (name, value) ->

let comma = if i = List.length values - 1 then "" else "," in

Printf.sprintf " %s = %d%s" name value comma

) values in

let footer = "};" in

String.concat "\n" (header :: constants @ [footer])

in

let generated = generate_enum_c enum_name enum_values in

let expected_lines = [

"enum xdp_action {";

" XDP_ABORTED = 0,";

" XDP_DROP = 1,";

" XDP_PASS = 2,";

" XDP_TX = 3";

"};"

] in

let expected = String.concat "\n" expected_lines in

let symbol_table = create_symbol_table () in

(* Add enum *)

let enum_values = [("XDP_PASS", Some (Signed64 2L)); ("XDP_DROP", Some (Signed64 1L))] in

let enum_def = EnumDef ("xdp_action", enum_values, { line = 1; column = 1; filename = "test" }) in

add_type_def symbol_table enum_def;

(* Verify the constant can be looked up *)

let symbol = lookup_symbol symbol_table "XDP_PASS" in

check bool "enum constant accessible" true (symbol <> None);

match symbol with

| Some s ->

(match s.kind with

| EnumConstant (_, Some value) ->

check int "enum constant value" 2 (Int64.to_int (IntegerValue.to_int64 value))

| _ -> check bool "wrong symbol type" false true)

(* Test empty enum *)

let empty_enum = EnumDef ("Empty", [], { line = 1; column = 1; filename = "test" }) in

let symbol_table = create_symbol_table () in

add_type_def symbol_table empty_enum;

let empty_symbol = lookup_symbol symbol_table "Empty" in

check bool "empty enum registered" true (empty_symbol <> None);

(* Test enum with duplicate names (should be handled by symbol table) *)

let duplicate_values = [("SAME", Some (Signed64 1L)); ("SAME", Some (Signed64 2L))] in

let duplicate_enum = EnumDef ("Duplicate", duplicate_values, { line = 1; column = 1; filename = "test" }) in

(* This should either succeed (last wins) or fail gracefully *)

try

add_type_def symbol_table duplicate_enum;

(* If it succeeds, verify the behavior *)

let dup_symbol = lookup_symbol symbol_table "SAME" in

check bool "duplicate handled" true (dup_symbol <> None)

with

| Symbol_error _ ->

(* If it fails, that's also acceptable behavior *)

let large_values = [

("SMALL", None);

("MEDIUM", Some (Signed64 1000L));

("LARGE", Some (Signed64 65535L));

("VERY_LARGE", Some (Signed64 4294967295L)) (* Max u32 *)

] in

let process_enum_values values =

let rec process_values acc current_value = function

| [] -> List.rev acc

| (const_name, None) :: rest ->

let processed_value = (const_name, Some (Signed64 (Int64.of_int current_value))) in

process_values (processed_value :: acc) (current_value + 1) rest

| (const_name, Some explicit_value) :: rest ->

let processed_value = (const_name, Some explicit_value) in

let explicit_int = Int64.to_int (IntegerValue.to_int64 explicit_value) in

process_values (processed_value :: acc) (explicit_int + 1) rest

in

process_values [] 0 values

in

let result = process_enum_values large_values in

let expected = [

("SMALL", Some 0);

("MEDIUM", Some 1000);

("LARGE", Some 65535);

("VERY_LARGE", Some 4294967295)

] in

let open Kernelscript.Ir in

let open Kernelscript.Ir_generator in

(* Create a symbol table with enum constants *)

let symbol_table = create_symbol_table () in

let enum_values = [("TCP", Some (Signed64 6L)); ("UDP", Some (Signed64 17L)); ("ICMP", Some (Signed64 1L))] in

let enum_def = EnumDef ("IpProtocol", enum_values, { line = 1; column = 1; filename = "test" }) in

add_type_def symbol_table enum_def;

(* Create AST identifier expression for enum constant *)

let tcp_identifier = make_expr (Identifier "TCP") dummy_pos in

(* Generate IR from AST *)

let ctx = create_context symbol_table in

let ir_value = lower_expression ctx tcp_identifier in

(* Verify that the IR contains IREnumConstant, not IRLiteral *)

(match ir_value.value_desc with

| IREnumConstant (enum_name, constant_name, numeric_value) ->

check string "IR enum name" "IpProtocol" enum_name;

check string "IR constant name" "TCP" constant_name;

check int "IR constant value" 6 (Int64.to_int (IntegerValue.to_int64 numeric_value))

| IRLiteral _ -> check bool "should not be IRLiteral" false true

let open Kernelscript.Ebpf_c_codegen in

let open Kernelscript.Ir in

(* Create IREnumConstant value *)

let enum_constant = make_ir_value (IREnumConstant ("IpProtocol", "TCP", Signed64 6L)) IRU32 dummy_pos in

(* Create a simple eBPF context *)

let ctx = create_c_context () in

(* Generate C code *)

let c_code = generate_c_value ctx enum_constant in

(* Verify that C code contains the constant name, not numeric value *)

check string "C code uses constant name" "TCP" c_code;

(* Test that it doesn't generate numeric value *)

(* Create a symbol table with enum definition *)

let symbol_table = create_symbol_table () in

let enum_values = [("TCP", Some (Signed64 6L)); ("UDP", Some (Signed64 17L)); ("ICMP", Some (Signed64 1L))] in

let enum_def = EnumDef ("IpProtocol", enum_values, { line = 1; column = 1; filename = "test" }) in

add_type_def symbol_table enum_def;

(* Test that the enum can be looked up from symbol table *)

let tcp_symbol = lookup_symbol symbol_table "TCP" in

check bool "TCP enum constant found in symbol table" true (tcp_symbol <> None);

(* Verify enum constant has correct value *)

(match tcp_symbol with

| Some symbol ->

(match symbol.kind with

| EnumConstant (enum_name, Some value) ->

check string "enum name" "IpProtocol" enum_name;

check int "TCP value" 6 (Int64.to_int (IntegerValue.to_int64 value))

| _ -> check bool "wrong symbol kind" false true)

(* Create symbol table with enum *)

let symbol_table = create_symbol_table () in

let enum_values = [("TCP", Some (Signed64 6L)); ("UDP", Some (Signed64 17L)); ("ICMP", Some (Signed64 1L))] in

let enum_def = EnumDef ("IpProtocol", enum_values, { line = 1; column = 1; filename = "test" }) in

add_type_def symbol_table enum_def;

(* Test that enum constants can be looked up *)

let tcp_symbol = lookup_symbol symbol_table "TCP" in

check bool "TCP enum constant found" true (tcp_symbol <> None);

(* Verify enum constant structure for match patterns *)

(match tcp_symbol with

| Some symbol ->

(match symbol.kind with

| EnumConstant (enum_name, Some value) ->

check string "match enum name" "IpProtocol" enum_name;

check string "match constant name" "TCP" "TCP";

check int "match constant value" 6 (Int64.to_int (IntegerValue.to_int64 value))

| _ -> check bool "wrong symbol kind for match" false true)

let open Kernelscript.Ir in

let open Kernelscript.Ir_generator in

(* Create symbol table with enum *)

let symbol_table = create_symbol_table () in

let enum_values = [("TCP", Some (Signed64 6L)); ("UDP", Some (Signed64 17L))] in

let enum_def = EnumDef ("IpProtocol", enum_values, { line = 1; column = 1; filename = "test" }) in

add_type_def symbol_table enum_def;

(* Create AST identifier for enum constant *)

let tcp_expr = make_expr (Identifier "TCP") dummy_pos in

(* Generate IR *)

let ctx = create_context symbol_table in

let ir_value = lower_expression ctx tcp_expr in

(* Verify it's NOT IRLiteral *)

(match ir_value.value_desc with

| IRLiteral _ -> check bool "should not be IRLiteral" false true

| IREnumConstant _ -> ()

let open Kernelscript.Ebpf_c_codegen in

let open Kernelscript.Ir in

(* Create symbol table with enum *)

let symbol_table = create_symbol_table () in

let enum_values = [("XDP_PASS", Some (Signed64 2L)); ("XDP_DROP", Some (Signed64 1L))] in

let enum_def = EnumDef ("XdpAction", enum_values, { line = 1; column = 1; filename = "test" }) in

add_type_def symbol_table enum_def;

(* Create IR with enum constant *)

let enum_constant = make_ir_value (IREnumConstant ("XdpAction", "XDP_PASS", Signed64 2L)) IRU32 dummy_pos in

(* Create context for C generation *)

let ctx = create_c_context () in

(* Test C code generation *)

let c_code = generate_c_value ctx enum_constant in

check string "C code preserves enum constant" "XDP_PASS" c_code;

(* Test symbol table preservation *)

let pass_symbol = lookup_symbol symbol_table "XDP_PASS" in

check bool "XDP_PASS symbol found" true (pass_symbol <> None);

let drop_symbol = lookup_symbol symbol_table "XDP_DROP" in

let open Kernelscript.Userspace_codegen in

let open Kernelscript.Ir in

(* Create IREnumConstant value *)

let enum_constant = make_ir_value (IREnumConstant ("Protocol", "HTTP", Signed64 80L)) IRU32 dummy_pos in

(* Create a simple userspace context *)

let ctx = create_userspace_context () in

(* Generate userspace C code *)

let c_code = generate_c_value_from_ir ctx enum_constant in

(* Verify that userspace code also preserves enum constant names *)

check string "userspace C code uses constant name" "HTTP" c_code;

let source = {|

enum test_enum {

NEGATIVE = -1,

ZERO = 0,

POSITIVE = 1,

LARGE_NEGATIVE = -999

}

|} in

let ast = parse_string source in

let enum_def = match ast with

| [TypeDef (EnumDef (name, variants, _))] ->

check string "enum name" "test_enum" name;

variants

| _ -> failwith "Expected single enum declaration"

in

(* Check that all values are parsed correctly *)

let expected = [

("NEGATIVE", Some (-1));

("ZERO", Some 0);

("POSITIVE", Some 1);

("LARGE_NEGATIVE", Some (-999))

] in

let source = {|

enum mixed_values {

NEG_FIRST = -5,

ZERO = 0,

POS_EXPLICIT = 42,

NEG_AGAIN = -100,

AUTO_ASSIGNED,

POSITIVE_AFTER = 200

}

|} in

let ast = parse_string source in

let enum_def = match ast with

| [TypeDef (EnumDef (name, variants, _))] ->

check string "enum name" "mixed_values" name;

variants

| _ -> failwith "Expected single enum declaration"

in

(* Check that negative values are parsed correctly alongside positive values *)

let expected = [

("NEG_FIRST", Some (-5));

("ZERO", Some 0);

("POS_EXPLICIT", Some 42);

("NEG_AGAIN", Some (-100));

("AUTO_ASSIGNED", None); (* Auto-assigned value *)

("POSITIVE_AFTER", Some 200)

] in

let source = {|

enum tc_action {

TC_ACT_UNSPEC = -1,

TC_ACT_OK = 0,

TC_ACT_RECLASSIFY = 1,

TC_ACT_SHOT = 2,

TC_ACT_PIPE = 3,

TC_ACT_STOLEN = 4,

TC_ACT_QUEUED = 5,

TC_ACT_REPEAT = 6,

TC_ACT_REDIRECT = 7,

TC_ACT_TRAP = 8,

}

|} in

let ast = parse_string source in

let enum_def = match ast with

| [TypeDef (EnumDef (name, variants, _))] ->

check string "enum name" "tc_action" name;

variants

| _ -> failwith "Expected single enum declaration"

in

(* Check the specific tc_action enum that was failing *)

let expected = [

("TC_ACT_UNSPEC", Some (-1));

("TC_ACT_OK", Some 0);

("TC_ACT_RECLASSIFY", Some 1);

("TC_ACT_SHOT", Some 2);

("TC_ACT_PIPE", Some 3);

("TC_ACT_STOLEN", Some 4);

("TC_ACT_QUEUED", Some 5);

("TC_ACT_REPEAT", Some 6);

("TC_ACT_REDIRECT", Some 7);

("TC_ACT_TRAP", Some 8)

] in

let source = {|

enum edge_cases {

VERY_NEGATIVE = -2147483648,

NEGATIVE_ONE = -1,

ZERO = 0,

POSITIVE_ONE = 1,

VERY_POSITIVE = 2147483647

}

|} in

let ast = parse_string source in

let enum_def = match ast with

| [TypeDef (EnumDef (name, variants, _))] ->

check string "enum name" "edge_cases" name;

variants

| _ -> failwith "Expected single enum declaration"

in

(* Check edge case values including minimum/maximum int32 values *)

let expected = [

("VERY_NEGATIVE", Some (-2147483648));

("NEGATIVE_ONE", Some (-1));

("ZERO", Some 0);

("POSITIVE_ONE", Some 1);

("VERY_POSITIVE", Some 2147483647)

] in

let source = {|

enum Protocol {

TCP = 6,

UDP = 17,

ICMP = 1

}

var protocol_stats : percpu_array<Protocol, u32>(32)

@helper

fn test_enum_index() -> u32 {

var proto = TCP

var count = protocol_stats[proto]

if (count != null) {

return count

} else {

return 0

}

}

@xdp fn packet_handler(ctx: *xdp_md) -> xdp_action {

return XDP_PASS

}

|} in

try

(* Parse the source *)

let ast = parse_string source in

(* Build symbol table with XDP builtin types *)

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

(* Type check the AST *)

let _typed_ast = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

(* If we reach here, type checking succeeded *)

()

with

| Type_error (msg, _) when String.contains msg 'A' && String.contains msg 'r' ->

(* If we get "Array index must be integer type" error, the test fails *)

check bool ("enum array index should be allowed: " ^ msg) false true

| Type_error (_, _) ->

(* Other type errors are acceptable for this test *)

()

| Parse_error (msg, _) ->

check bool ("parse error: " ^ msg) false true

| e ->