expr_desc = Literal (IntLit (Signed64 (Int64.of_int value), None));

expr_type = Some U32;

expr_pos = dummy_loc;

type_checked = false;

program_context = None;

map_scope = None;

expr_desc = Identifier name;

expr_type = None;

expr_pos = dummy_loc;

type_checked = false;

program_context = None;

map_scope = None;

expr_desc = BinaryOp (left, op, right);

expr_type = None;

expr_pos = dummy_loc;

type_checked = false;

program_context = None;

map_scope = None;

expr_desc = Call (make_id name, args);

expr_type = None;

expr_pos = dummy_loc;

type_checked = false;

program_context = None;

map_scope = None;

expr_desc = Literal (ArrayLit (ExplicitArray (List.map (function

| {expr_desc = Literal lit; _} -> lit

| _ -> IntLit (Signed64 0L, None) (* fallback *)

) elements)));

expr_type = None;

expr_pos = dummy_loc;

type_checked = false;

program_context = None;

map_scope = None;

let ast = parse_string code in

(* Create symbol table with test builtin types *)

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

(* Run type checking with builtin types loaded *)

let (typed_ast, _) = Kernelscript.Type_checker.type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

let program_text = Printf.sprintf {|

@xdp fn test() -> u32 {

%s

return 0

}

|} input in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let actual_stmts = List.rev (List.tl (List.rev main_func.func_body)) in

check int "statement count" (List.length expected) (List.length actual_stmts)

| _ -> fail "Expected attributed function declaration"

with

let program_text = {|

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

return 2

}

|} in

try

let ast = parse_string program_text in

check int "AST length" 1 (List.length ast);

match List.hd ast with

| AttributedFunction attr_func ->

check string "function name" "test" attr_func.attr_function.func_name;

(* Check attribute is xdp *)

let has_xdp_attr = List.exists (function SimpleAttribute "xdp" -> true | _ -> false) attr_func.attr_list in

check bool "has xdp attribute" true has_xdp_attr

| _ -> fail "Expected attributed function declaration"

with

let expressions = [

("42", true);

("x + y", true);

("func(a, b)", true);

("arr[index]", true);

("obj.field", true);

("(x + y) * z", true);

("!condition", true);

("-value", true);

] in

List.iter (fun (expr_text, should_succeed) ->

let program_text = Printf.sprintf {|

@xdp fn test() -> u32 {

var result = %s

return 0

}

|} expr_text in

try

let _ = parse_string program_text in

check bool ("expression parsing: " ^ expr_text) should_succeed true

with

| _ -> check bool ("expression parsing: " ^ expr_text) should_succeed false

let statements = [

("var x = 42", true);

("var y: u32 = 100", true);

("x = 50", true);

("return x", true);

("return", true);

("if (true) { return 1 }", true);

("if (x > 0) { return 1 } else { return 0 }", true);

] in

List.iter (fun (stmt_text, should_succeed) ->

let program_text = Printf.sprintf {|

@xdp fn test() -> u32 {

%s

return 0

}

|} stmt_text in

try

let _ = parse_string program_text in

check bool ("statement parsing: " ^ stmt_text) should_succeed true

with

| _ -> check bool ("statement parsing: " ^ stmt_text) should_succeed false

let program_text = {|

@helper

fn helper(x: u32, y: u32) -> u32 {

return x + y

}

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

var result = helper(10, 20)

return 2

}

|} in

try

let ast = parse_string program_text in

(* First item should be the helper attributed function *)

match List.hd ast with

| AttributedFunction attr_func ->

check string "helper function name" "helper" attr_func.attr_function.func_name;

check int "helper parameters" 2 (List.length attr_func.attr_function.func_params);

check bool "helper return type" true (attr_func.attr_function.func_return_type = Some (make_unnamed_return U32));

let has_helper_attr = List.exists (function

| SimpleAttribute "helper" -> true

| _ -> false

) attr_func.attr_list in

check bool "has helper attribute" true has_helper_attr

| _ -> fail "Expected attributed function declaration"

with

let program_types = [

("xdp", Xdp);

("tc", Tc);

("probe", Probe Fprobe); (* @probe without offset defaults to fprobe *)

("tracepoint", Tracepoint);

] in

List.iter (fun (type_text, _expected_type) ->

let program_text = Printf.sprintf {|

@%s fn test() -> u32 {

return 0

}

|} type_text in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let has_expected_attr = List.exists (function

| SimpleAttribute attr_name -> attr_name = type_text

| _ -> false

) attr_func.attr_list in

check bool ("program type: " ^ type_text) true has_expected_attr

| _ -> fail "Expected attributed function declaration"

with

| _ -> fail ("Failed to parse program type: " ^ type_text)

let types = [

("u8", U8);

("u32", U32);

("u64", U64);

("bool", Bool);

("char", Char);

] in

List.iter (fun (type_text, expected_type) ->

let program_text = Printf.sprintf {|

@xdp fn test() -> u32 {

var x: %s = 0

return 0

}

|} type_text in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let decl_stmt = List.hd main_func.func_body in

(match decl_stmt.stmt_desc with

| Declaration (_, Some parsed_type, _) ->

check bool ("BPF type: " ^ type_text) true (parsed_type = expected_type)

| _ -> fail "Expected declaration statement")

| _ -> fail "Expected attributed function declaration"

with

| _ -> fail ("Failed to parse BPF type: " ^ type_text)

let program_text = {|

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

var x = 10

if (x > 5) {

x = x + 1

} else {

x = x - 1

}

while (x > 0) {

x = x - 1

}

return 2

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

check bool "control flow statements" true (List.length main_func.func_body >= 4)

| _ -> fail "Expected attributed function declaration"

with

let invalid_programs = [

"invalid syntax";

"@xdp fn test { }"; (* missing parameters and return type *)

"@xdp fn test() { }"; (* missing return type *)

"@xdp fn test() -> u32"; (* missing body *)

] in

List.iter (fun invalid_text ->

try

let _ = parse_string invalid_text in

fail ("Should have failed to parse: " ^ invalid_text)

with

| _ -> ()

let program_text = {|

@xdp fn test() -> u32 {

var result = 1 + 2 * 3

var comparison = x < y && a > b

var complex = (a + b) * c - d / e

return 0

}

|} in

try

let _ = parse_string program_text in

()

with

let program_text = {|

var packet_count : hash<u32, u64>(1024)

@helper

fn process_packet(src_ip: u32) -> u64 {

var count = packet_count[src_ip]

packet_count[src_ip] = count + 1

return count

}

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

var src_ip = 0x12345678

var count = process_packet(src_ip)

if (count > 100) {

return XDP_DROP

}

return XDP_PASS

}

|} in

try

let ast = parse_string_with_builtins program_text in

check int "complete program AST length" 3 (List.length ast);

(* Check global variable declaration with map type *)

(match List.hd ast with

| GlobalVarDecl global_var ->

check string "map variable name" "packet_count" global_var.global_var_name;

(match global_var.global_var_type with

| Some (Map (key_type, value_type, map_type, size)) ->

check bool "map key type" true (key_type = U32);

check bool "map value type" true (value_type = U64);

check bool "map type" true (map_type = Hash);

check int "map size" 1024 size

| _ -> fail "Expected map type")

| _ -> fail "Expected global variable declaration with map type");

(* Check helper function declaration *)

(match List.nth ast 1 with

| AttributedFunction attr_func ->

check string "helper function name" "process_packet" attr_func.attr_function.func_name;

check int "helper function parameters" 1 (List.length attr_func.attr_function.func_params);

check bool "helper function return type" true (attr_func.attr_function.func_return_type = Some (make_unnamed_return U64));

let has_helper_attr = List.exists (function

| SimpleAttribute "helper" -> true

| _ -> false

) attr_func.attr_list in

check bool "has helper attribute" true has_helper_attr

| _ -> fail "Expected helper attributed function declaration");

(* Check attributed function declaration *)

(match List.nth ast 2 with

| AttributedFunction attr_func ->

check string "function name" "packet_filter" attr_func.attr_function.func_name

| _ -> fail "Expected attributed function declaration")

with

let program_text = {|

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

var x = 10

if (x > 5) {

return 1

}

return 2

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let if_stmt = List.nth main_func.func_body 1 in

(match if_stmt.stmt_desc with

| If (_, then_stmts, None) ->

check int "then branch has statements" 1 (List.length then_stmts);

check bool "no else branch" true (None = None)

| _ -> fail "Expected if statement without else")

| _ -> fail "Expected attributed function declaration"

with

let program_text = {|

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

var x = 10

if (x > 15) {

return 1

} else {

return 2

}

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let if_stmt = List.nth main_func.func_body 1 in

(match if_stmt.stmt_desc with

| If (_, then_stmts, Some else_stmts) ->

check int "then branch has statements" 1 (List.length then_stmts);

check int "else branch has statements" 1 (List.length else_stmts)

| _ -> fail "Expected if-else statement")

| _ -> fail "Expected attributed function declaration"

with

let program_text = {|

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

var x = 10

if (x > 20) {

return 1

} else if (x > 10) {

return 2

} else if (x > 5) {

return 3

} else {

return 4

}

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let if_stmt = List.nth main_func.func_body 1 in

(match if_stmt.stmt_desc with

| If (_, then_stmts, Some else_stmts) ->

check int "first then branch" 1 (List.length then_stmts);

check int "else contains nested if" 1 (List.length else_stmts);

(* Check that else contains another if statement *)

(match (List.hd else_stmts).stmt_desc with

| If (_, _, Some _) -> ()

| _ -> fail "Expected nested if-else")

| _ -> fail "Expected if-else statement")

| _ -> fail "Expected attributed function declaration"

with

let program_text = {|

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

var x = 10

var y = 20

if (x > 5) {

if (y > 15) {

return 1

} else {

return 2

}

} else {

return 3

}

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let if_stmt = List.nth main_func.func_body 2 in

(match if_stmt.stmt_desc with

| If (_, then_stmts, Some _) ->

check int "outer then branch" 1 (List.length then_stmts);

(* Check nested if in then branch *)

(match (List.hd then_stmts).stmt_desc with

| If (_, nested_then, Some nested_else) ->

check int "nested then" 1 (List.length nested_then);

check int "nested else" 1 (List.length nested_else)

| _ -> fail "Expected nested if in then branch")

| _ -> fail "Expected nested if statement")

| _ -> fail "Expected attributed function declaration"

with

let program_text = {|

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

var x = 10

if (x > 5) {

var y = x + 1

var z = y * 2

x = z - 1

return 1

} else {

x = x - 1

var w = x / 2

return 2

}

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let if_stmt = List.nth main_func.func_body 1 in

(match if_stmt.stmt_desc with

| If (_, then_stmts, Some else_stmts) ->

check int "then branch multiple statements" 4 (List.length then_stmts);

check int "else branch multiple statements" 3 (List.length else_stmts)

| _ -> fail "Expected if statement with multiple statements")

| _ -> fail "Expected attributed function declaration"

with

let program_text = {|

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

var x = 10

var y = 20

// SPEC-compliant syntax with mandatory parentheses around condition

if (x > 5) {

return 1

}

// Complex conditions also require parentheses

if (x > 5 && y < 25) {

return 2

}

// Parentheses for grouping expressions should still work

if ((x + y) > 25) {

return 3

}

return 0

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

(* Should have multiple if statements *)

check bool "SPEC-compliant syntax works" true (List.length main_func.func_body >= 6)

| _ -> fail "Expected attributed function declaration"

with

let error_cases = [

("missing condition", {|

@xdp fn test() -> u32 {

if {

return 1

}

return 0

}

|});

("missing braces", {|

@xdp fn test() -> u32 {

if x > 5

return 1

return 0

}

|});

] in

List.iter (fun (desc, code) ->

try

let _ = parse_string code in

fail ("Should have failed: " ^ desc)

with

| Parse_error (_, _) -> ()

| _ -> fail ("Expected parse error for: " ^ desc)

let program_text = {|

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

for (i in 0..10) {

return 1

}

return 2

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let for_stmt = List.hd main_func.func_body in

(match for_stmt.stmt_desc with

| For (var, _, _, body) ->

check string "for loop variable" "i" var;

check int "for loop body has statements" 1 (List.length body)

| _ -> fail "Expected for loop")

| _ -> fail "Expected attributed function declaration"

with

let program_text = {|

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

for (i in 0..5) {

var x = i * 2

}

return 2

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let for_stmt = List.hd main_func.func_body in

(match for_stmt.stmt_desc with

| For (var, _, _, body) ->

check string "for loop variable" "i" var;

check int "for loop body has statements" 1 (List.length body)

| _ -> fail "Expected for loop")

| _ -> fail "Expected attributed function declaration"

with

let program_text = {|

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

for (i in 0..3) {

var v = i

return v

}

return 2

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let for_stmt = List.hd main_func.func_body in

(match for_stmt.stmt_desc with

| For (var, _, _, body) ->

check string "for loop variable" "i" var;

check int "for loop body has statements" 2 (List.length body)

| _ -> fail "Expected for loop")

| _ -> fail "Expected attributed function declaration"

with

let program_text = {|

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

for (i in 0..3) {

for (j in 0..2) {

return 1

}

}

return 2

}

|} in

try

let ast = parse_string program_text in

match List.hd ast with

| AttributedFunction attr_func ->

let main_func = attr_func.attr_function in

let outer_for = List.hd main_func.func_body in

(match outer_for.stmt_desc with

| For (_, _, _, outer_body) ->

check int "outer for loop body has statements" 1 (List.length outer_body);

(* Check nested for loop *)

let inner_for = List.hd outer_body in

(match inner_for.stmt_desc with

| For (_, _, _, inner_body) ->

check int "inner for loop body has statements" 1 (List.length inner_body)

| _ -> fail "Expected nested for loop")

| _ -> fail "Expected outer for loop")

| _ -> fail "Expected attributed function declaration"

with

let test_cases = [

(* Zero range - should work *)

("for (i in 5..5) { var x = i }",

[make_for_stmt "i" (make_int_lit 5) (make_int_lit 5) [make_decl "x" (make_id "i")]]);

(* Variable bounds - use simple constants *)

("for (j in 2..8) { var y = j }",

[make_for_stmt "j" (make_int_lit 2) (make_int_lit 8) [make_decl "y" (make_id "j")]]);

] in

List.iter (fun (input, expected) ->

test_parse_statements input expected

let input = "for (i in 0..3) { var x = i } for (j in 1..5) { var y = j }" in

let expected = [

make_for_stmt "i" (make_int_lit 0) (make_int_lit 3) [make_decl "x" (make_id "i")];

make_for_stmt "j" (make_int_lit 1) (make_int_lit 5) [make_decl "y" (make_id "j")];

] in

(* Test that we can parse different kinds of loop bounds *)

let input = "for (i in 0..5) { var x = i } for (j in 2..8) { var y = j }" in

let expected = [

make_for_stmt "i" (make_int_lit 0) (make_int_lit 5) [make_decl "x" (make_id "i")];

make_for_stmt "j" (make_int_lit 2) (make_int_lit 8) [make_decl "y" (make_id "j")];

] in

let test_cases = [

("var x: u32 = 10", true);

("var y = 20", true);

("var z: bool = true", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("if (true) { var x = 10 }", true);

("if (false) { var y = 20 } else { var z = 30 }", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("while (true) { var x = 10 }", true);

("while (false) { break }", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("for (i in 0..10) { var x = 10 }", true);

("for (j in 1..5) { break }", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("return 42", true);

("return true", true);

("return", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("print(42)", true);

("helper(x, y)", true);

("process()", true);

("var scaled = read(cache).scaled", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("if (true) { while (false) { var x = 10 } }", true);

("for (i in 0..5) { if (i == 2) { break } }", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("for (i in 0..10) { var x = 10 }", true);

("for (j in 1..100) { var x = 10 }", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("for (i in 0..5) { var x = 10 }", true);

("while (i < 10) { var x = 10 }", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("for (i in 0..3) { var x = i }", true);

("for (j in 1..5) { var y = j }", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let test_cases = [

("for (i in 5..5) { var x = i }", true);

("for (i in 0..0) { var y = i }", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let complex_tests = [

("for (i in 0..3) { var x = i } for (j in 1..5) { var y = j }", "multiple for loops with variables");

("for (i in 0..5) { var x = i } for (j in 2..8) { var y = j }", "larger range for loops with variables");

] in

List.iter (fun (input, description) ->

try

let _ = parse_string input in

Printf.printf "✓ %s: %s\n" description input;

with

| e -> Printf.printf "✗ %s failed: %s\n" description (Printexc.to_string e)

let source = {|

fn test() -> i32 {

var x: u32 = 10

x += 5

x -= 3

x *= 2

x /= 4

x %= 3

return 0

}

|} in

try

let ast = parse_string source in

let func = List.find (function

| GlobalFunction f when f.func_name = "test" -> true

| _ -> false) ast in

(match func with

| GlobalFunction f ->

let statements = f.func_body in

(* Check that we have 6 statements: var declaration + 5 compound assignments + return *)

assert (List.length statements = 7);

(* Check the compound assignment statements *)

(match List.nth statements 1 with

| { stmt_desc = CompoundAssignment ("x", Add, _); _ } -> ()

| _ -> failwith "Expected x += 5");

(match List.nth statements 2 with

| { stmt_desc = CompoundAssignment ("x", Sub, _); _ } -> ()

| _ -> failwith "Expected x -= 3");

(match List.nth statements 3 with

| { stmt_desc = CompoundAssignment ("x", Mul, _); _ } -> ()

| _ -> failwith "Expected x *= 2");

(match List.nth statements 4 with

| { stmt_desc = CompoundAssignment ("x", Div, _); _ } -> ()

| _ -> failwith "Expected x /= 4");

(match List.nth statements 5 with

| { stmt_desc = CompoundAssignment ("x", Mod, _); _ } -> ()

| _ -> failwith "Expected x %= 3");