try

let _ = Str.search_forward (Str.regexp_string substr) str 0 in

true

let program_text = {|

@helper

fn log_message(msg: u32) -> void {

print("Message:", msg)

return

}

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

log_message(42)

return XDP_PASS

}

fn main() -> i32 {

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let multi_ir = lower_multi_program annotated_ast symbol_table "test_void_naked_return" in

(* Verify the void function is in the multi-program IR *)

let has_log_func = List.exists (fun func ->

func.Kernelscript.Ir.func_name = "log_message"

) (Kernelscript.Ir.get_kernel_functions multi_ir) in

check bool "void function with naked return should be accepted" true has_log_func

with

let program_text = {|

@helper

fn bad_void_func() -> void {

return 42 // This should fail - void function returning a value

}

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

bad_void_func()

return XDP_PASS

}

fn main() -> i32 {

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let _ = lower_multi_program annotated_ast symbol_table "test_void_with_value" in

fail "Void function returning a value should be rejected"

with

| Type_error (msg, _) ->

check bool "correctly rejected void function with return value" true

(String.contains msg 'v' || String.contains msg 'V' || String.contains msg 'r')

| _ ->

let program_text = {|

@helper

fn setup_logging() -> void {

print("Logging initialized")

// No explicit return statement

}

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

setup_logging()

return XDP_PASS

}

fn main() -> i32 {

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let multi_ir = lower_multi_program annotated_ast symbol_table "test_void_no_return" in

(* Verify the void function is in the multi-program IR *)

let has_setup_func = List.exists (fun func ->

func.Kernelscript.Ir.func_name = "setup_logging"

) (Kernelscript.Ir.get_kernel_functions multi_ir) in

check bool "void function without return should be accepted" true has_setup_func

with

let program_text = {|

@helper

fn conditional_log(should_log: bool, msg: u32) -> void {

if (should_log) {

print("Message:", msg)

return

}

print("No logging")

return

}

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

conditional_log(true, 123)

return XDP_PASS

}

fn main() -> i32 {

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let multi_ir = lower_multi_program annotated_ast symbol_table "test_void_conditional" in

(* Verify the void function is in the multi-program IR *)

let has_conditional_func = List.exists (fun func ->

func.Kernelscript.Ir.func_name = "conditional_log"

) (Kernelscript.Ir.get_kernel_functions multi_ir) in

check bool "void function with conditional returns should be accepted" true has_conditional_func

with

let program_text = {|

@helper

fn bad_mixed_returns(flag: bool) -> void {

if (flag) {

return 1 // This should fail - returning value in void function

}

return // This is OK - naked return

}

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

bad_mixed_returns(true)

return XDP_PASS

}

fn main() -> i32 {

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let _ = lower_multi_program annotated_ast symbol_table "test_void_mixed" in

fail "Void function with mixed return types should be rejected"

with

| Type_error (msg, _) ->

check bool "correctly rejected void function with mixed returns" true

(String.contains msg 'v' || String.contains msg 'V' || String.contains msg 'r')

| _ ->

let program_text = {|

@helper

fn log_event(event_id: u32) -> void {

print("Event:", event_id)

return

}

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

log_event(100)

return XDP_PASS

}

fn main() -> i32 {

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let multi_ir = lower_multi_program annotated_ast symbol_table "test_void_codegen" in

(* Generate eBPF C code *)

let ebpf_code = generate_c_multi_program multi_ir in

(* Verify the void function is generated with correct signature *)

check bool "void function should have void return type in C" true

(String.contains ebpf_code 'v' && String.contains ebpf_code 'l');

(* Note: There's a known issue where void function calls are assigned to variables in C generation *)

(* This doesn't affect correctness but could be optimized in the future *)

()

with

let program_text = {|

fn cleanup_resources() -> void {

print("Cleaning up resources")

return

}

fn main() -> i32 {

cleanup_resources()

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (_annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

(* If we get here without exceptions, the userspace void function was accepted *)

(* We don't need to generate IR for userspace-only tests, type checking is sufficient *)

()

with

let program_text = {|

@helper

fn log_and_return_void() -> void {

print("Logging")

return

}

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

var result = log_and_return_void() // This should fail - void function in expression

return XDP_PASS

}

fn main() -> i32 {

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let _ = lower_multi_program annotated_ast symbol_table "test_void_in_expr" in

fail "Void function used in expression should be rejected"

with

| Type_error (msg, _) ->

check bool "correctly rejected void function in expression" true

(String.contains msg 'v' || String.contains msg 'V' || String.contains msg 'e')

| _ ->

let program_text = {|

extern custom_void_kfunc(value: u32) -> void

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

custom_void_kfunc(42)

return XDP_PASS

}

fn main() -> i32 {

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let multi_ir = lower_multi_program annotated_ast symbol_table "test_extern_void" in

(* Verify the program compiles successfully *)

let has_xdp_prog = List.exists (fun prog ->

prog.Kernelscript.Ir.name = "test_prog"

) (Kernelscript.Ir.get_programs multi_ir) in

check bool "extern void kfunc should be accepted" true has_xdp_prog

with

let program_text = {|

@helper

fn complex_void_func(mode: u32) -> void {

if (mode == 1) {

print("Mode 1")

return

} else if (mode == 2) {

print("Mode 2")

return

} else {

print("Default mode")

// Implicit return at end

}

}

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

complex_void_func(1)

return XDP_PASS

}

fn main() -> i32 {

return 0

}

|} in

try

let ast = parse_string program_text in

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let multi_ir = lower_multi_program annotated_ast symbol_table "test_void_complex" in

(* Verify the void function is in the multi-program IR *)

let has_complex_func = List.exists (fun func ->

func.Kernelscript.Ir.func_name = "complex_void_func"

) (Kernelscript.Ir.get_kernel_functions multi_ir) in

check bool "void function with complex control flow should be accepted" true has_complex_func

with

let program_text = {|

@helper fn set_qos_mark(ctx: *__sk_buff, class: str(16)) -> void { }

@tc("ingress") fn qos_marker(ctx: *__sk_buff) -> i32 {

set_qos_mark(ctx, "high_priority")

return 0

}

|} in

let ast = parse_string program_text in

let symbol_table = Kernelscript.Symbol_table.build_symbol_table ast in

let (typed_ast, _) = type_check_and_annotate_ast ast in

let ir = generate_ir typed_ast symbol_table "test_void" in

(* Generate eBPF C code *)

let (c_code, _) = Kernelscript.Ebpf_c_codegen.compile_multi_to_c_with_analysis ir in

(* Check that void function is declared correctly *)

check bool "void function declaration" true

(contains_substr c_code "void set_qos_mark(struct __sk_buff* ctx, str_16_t class)");

(* Check that void function call does NOT generate temporary variable assignment *)

check bool "no temporary variable for void call" false

(contains_substr c_code "void var_");

(* Check that void function call is generated correctly without assignment *)

check bool "correct void function call" true

(contains_substr c_code "set_qos_mark(ctx, ");

(* Ensure the call is a standalone statement, not an assignment *)

check bool "void call as statement" true

(contains_substr c_code "set_qos_mark(ctx, str_lit_1);");

(* Ensure no invalid C syntax like "void var_X = function_call()" *)

let lines = String.split_on_char '\n' c_code in

let has_invalid_void_assignment = List.exists (fun line ->

contains_substr line "void " && contains_substr line " = " && contains_substr line "set_qos_mark"

) lines in