match decl with

| TypeDef _ -> true

| StructDecl _ -> true

| ConfigDecl _ -> true

| ExternKfuncDecl _ -> true

| IncludeDecl _ -> true (* Allow nested includes *)

| GlobalVarDecl _ -> true (* Allow global variable declarations *)

| AttributedFunction attr_func ->

(* Check if this is just a declaration (no body) *)

(match attr_func.attr_function.func_body with

| [] -> true (* Empty body = declaration only *)

| _ -> false) (* Has body = implementation *)

| GlobalFunction func ->

(* Check if this is just a declaration (no body) *)

(match func.func_body with

| [] -> true (* Empty body = declaration only *)

| _ -> false) (* Has body = implementation *)

| MapDecl _ -> true (* Allow map declarations *)

| ImplBlock _ -> false (* Impl blocks not allowed in headers *)

let validate_decl decl =

if not (validate_header_declaration decl) then

let error_msg = match decl with

| AttributedFunction attr_func ->

FunctionBodyFound attr_func.attr_function.func_name

| GlobalFunction func ->

FunctionBodyFound func.func_name

| ImplBlock impl_block ->

InvalidDeclaration ("impl block '" ^ impl_block.impl_name ^ "' not allowed in headers")

| _ ->

InvalidDeclaration "unknown invalid declaration type"

in

let pos = { line = 0; column = 0; filename = file_path } in

raise (Include_validation_error (error_msg, file_path, pos))

in

(* Resolve relative paths *)

let file_path = if Filename.is_relative include_decl.include_path then

Filename.concat (Filename.dirname base_path) include_decl.include_path

else

include_decl.include_path

in

(* Validate file extension *)

validate_file_extension file_path;

(* Check if file exists *)

if not (Sys.file_exists file_path) then

include_error ("Include file not found: " ^ file_path) include_decl.include_pos;

try

(* Parse the included file *)

let ic = open_in file_path in

let content = really_input_string ic (in_channel_length ic) in

close_in ic;

let lexbuf = Lexing.from_string content in

Lexing.set_filename lexbuf file_path;

let ast = Parser.program Lexer.token lexbuf in

(* Validate that it's a proper header file *)

validate_header_file file_path ast;

(* Update position information in all declarations to include the correct filename *)

let update_position_in_declaration decl =

match decl with

| Ast.TypeDef (Ast.EnumDef (name, values, pos)) ->

Ast.TypeDef (Ast.EnumDef (name, values, { pos with filename = file_path }))

| Ast.TypeDef (Ast.StructDef (name, fields, pos)) ->

Ast.TypeDef (Ast.StructDef (name, fields, { pos with filename = file_path }))

| Ast.TypeDef (Ast.TypeAlias (name, typ, pos)) ->

Ast.TypeDef (Ast.TypeAlias (name, typ, { pos with filename = file_path }))

| Ast.StructDecl struct_def ->

Ast.StructDecl { struct_def with struct_pos = { struct_def.struct_pos with filename = file_path } }

| other -> other (* Other declaration types don't need position updates for our filtering *)

in

(* Return the parsed declarations with updated positions *)

List.map update_position_in_declaration ast

with

| Include_validation_error (err, file_path, pos) ->

let error_msg = match err with

| FunctionBodyFound func_name ->

Printf.sprintf "Header file '%s' contains function implementation '%s'. Header files (.kh) should only contain declarations. Move implementations to .ks files." file_path func_name

| InvalidExtension file_path ->

Printf.sprintf "Include directive can only include .kh header files, but found: %s" file_path

| InvalidDeclaration desc ->

Printf.sprintf "Header file '%s' contains invalid declaration: %s" file_path desc

in

include_error error_msg pos

| Sys_error msg ->

let pos = { line = 0; column = 0; filename = file_path } in

include_error ("Cannot read header file: " ^ msg) pos

| Parsing.Parse_error ->

let pos = { line = 0; column = 0; filename = file_path } in

let rec process_decls decls =

List.fold_left (fun acc decl ->

match decl with

| IncludeDecl include_decl ->

(* Resolve the include and get its declarations *)

let included_ast = resolve_include include_decl base_path in

(* Recursively process includes in the included file *)

let processed_included = process_decls included_ast in

(* Add the included declarations to our AST (flatten) *)

acc @ processed_included

| _ ->

(* Keep non-include declarations as-is *)

acc @ [decl]

) [] decls

in

List.filter_map (function

| IncludeDecl include_decl -> Some include_decl

| _ -> None

) ast