Introduce import system to support KernelScript and Python modules. Update AST, parser, and type checker to handle new import syntax and module calls. Enhance evaluation and IR generation for module function calls. Update symbol table to track imported modules and functions.

Author: congwang-mk

SPEC.md

@@ -89,6 +89,49 @@ fn main(args: Args) -> i32 {
 }
 ```
 
+### 1.4 Unified Import System
+
+KernelScript supports importing both KernelScript modules and external language modules using a unified syntax. Import behavior is automatically determined by file extension:
+
+```kernelscript
+// Import KernelScript modules (.ks files)
+import utils from "./common/utils.ks"           // Functions, types, maps, configs
+import packet_helpers from "../net/helpers.ks"  // Shared across eBPF and userspace
+
+// Import Python modules (.py files) - userspace only
+import ml_analysis from "./ml/threat_analysis.py"
+import data_processor from "./analytics/stats.py"
+
+// Usage is identical regardless of source language
+@xdp
+fn intelligent_filter(ctx: *xdp_md) -> xdp_action {
+    // Use KernelScript imported functions
+    var protocol = utils.extract_protocol(ctx)
+    
+    // Use Python imported functions (FFI bridge in userspace)
+    var packet_data = ctx->data
+    var packet_len = ctx->data_end - ctx->data
+    var threat_score = ml_analysis.compute_threat_score(packet_data, packet_len)
+    
+    if (threat_score > 0.8) {
+        return XDP_DROP
+    }
+    return XDP_PASS
+}
+
+fn main() -> i32 {
+    // Both KernelScript and Python functions work seamlessly in userspace
+    var is_valid = utils.validate_config()
+    var model_stats = ml_analysis.get_model_statistics()
+    
+    print("Config valid: %d, Model accuracy: %f", is_valid, model_stats.accuracy)
+    
+    var prog = load(intelligent_filter)
+    attach(prog, "eth0", 0)
+    return 0
+}
+```
+
 ## 2. Lexical Structure
 
 ### 2.1 Keywords
@@ -4449,9 +4492,17 @@ boolean_literal = "true" | "false"
 array_literal = "[" [ expression { "," expression } ] "]" 
 null_literal = "null" 
 
-(* Import declarations *)
-import_declaration = "import" import_target 
-import_target = identifier | string_literal 
+(* Import declarations - unified syntax for KernelScript and external languages *)
+import_declaration = "import" identifier "from" string_literal 
+
+(* Examples:
+   import utils from "./common/utils.ks"          // KernelScript import
+   import ml_analysis from "./ml/threat.py"       // Python import (userspace only)
+   
+   Import behavior is determined by file extension:
+   - .ks files: Import KernelScript symbols (functions, types, maps, configs)  
+   - .py files: Import Python functions with automatic FFI bridging (userspace only)
+*) 
 
 (* Identifiers and basic tokens *)
 identifier = letter { letter | digit | "_" } 

examples/import/network_utils.py

@@ -0,0 +1,28 @@
+"""
+Simple network utilities for KernelScript import testing
+"""
+
+def calculate_bandwidth(packets_per_second, avg_packet_size=1500):
+    """Calculate bandwidth in bytes per second"""
+    return packets_per_second * avg_packet_size
+
+def is_rate_limited(current_rate, max_rate=1000000):
+    """Check if current rate exceeds maximum allowed rate"""
+    return current_rate > max_rate
+
+def get_default_mtu():
+    """Get default MTU size"""
+    return 1500
+
+def format_packet_count(count):
+    """Format packet count for display"""
+    if count > 1000000:
+        return f"{count / 1000000:.1f}M packets"
+    elif count > 1000:
+        return f"{count / 1000:.1f}K packets"
+    else:
+        return f"{count} packets"
+
+# Configuration constants
+MAX_PACKET_SIZE = 9000
+DEFAULT_TIMEOUT = 30 

examples/import/simple_utils.ks

@@ -0,0 +1,9 @@
+// Simple utilities for import testing
+
+fn validate_config() -> bool {
+    return true
+}
+
+fn get_status() -> u32 {
+    return 42
+} 

examples/import_demo.ks

@@ -0,0 +1,38 @@
+// Working demo of unified import syntax
+
+// Import KernelScript module (compiled to .so)
+import utils from "./import/simple_utils.ks"
+
+// Import Python module (uses Python bridge)
+import network_utils from "./import/network_utils.py"
+
+config network {
+    enable_filtering: bool = false,
+    status_code: u32 = 0,
+    packet_count: u32 = 5000,
+}
+
+@xdp 
+fn intelligent_filter(ctx: *xdp_md) -> xdp_action {
+    if (network.enable_filtering) {
+        return XDP_DROP
+    }
+    return XDP_PASS
+}
+
+fn main() -> i32 {
+    // Use KernelScript imported functions (compiled C binding)
+    var is_valid = utils.validate_config()
+    var status = utils.get_status()
+    
+    // Use Python imported functions (Python bridge) - simplified calls
+    var mtu = network_utils.get_default_mtu()
+    
+    print("=== Import Demo Results ===")
+    print("KernelScript utils - Config valid: %d, Status: %d", is_valid, status)
+    print("Python network_utils - MTU: %d", mtu)
+    
+    var prog = load(intelligent_filter)
+    attach(prog, "eth0", 0)
+    return 0
+} 

src/ast.ml

@@ -162,6 +162,7 @@ and expr_desc =
   | ConfigAccess of string * string  (* config_name, field_name *)
   | Call of expr * expr list  (* Unified call: callee_expression * arguments *)
   | TailCall of string * expr list  (* function_name, arguments - for explicit tail calls *)
+  | ModuleCall of module_call  (* module.function(args) calls *)
   | ArrayAccess of expr * expr
   | FieldAccess of expr * string
   | ArrowAccess of expr * string  (* pointer->field *)
@@ -170,6 +171,14 @@ and expr_desc =
   | StructLiteral of string * (string * expr) list
   | Match of expr * match_arm list  (* match (expr) { arms } *)
 
+(** Module function call *)
+and module_call = {
+  module_name: string;
+  function_name: string;
+  args: expr list;
+  call_pos: position;
+}
+
 (** Match pattern for basic match expressions *)
 and match_pattern =
   | ConstantPattern of literal  (* 42, "string", true, etc. *)
@@ -309,6 +318,17 @@ type impl_block = {
   impl_pos: position;
 }
 
+(** Import source type - determined by file extension *)
+type import_source_type = KernelScript | Python
+
+(** Import declaration *)
+type import_declaration = {
+  module_name: string;        (* Local name for the imported module *)
+  source_path: string;        (* File path *)
+  source_type: import_source_type; (* Determined from file extension *)
+  import_pos: position;
+}
+
 (** Top-level declarations *)
 type declaration =
   | AttributedFunction of attributed_function
@@ -319,6 +339,7 @@ type declaration =
   | StructDecl of struct_def
   | GlobalVarDecl of global_variable_declaration
   | ImplBlock of impl_block
+  | ImportDecl of import_declaration
 
 (** Complete AST *)
 type ast = declaration list
@@ -488,6 +509,31 @@ let make_default_pattern () = DefaultPattern
 let make_match_expr matched_expr arms pos =
   make_expr (Match (matched_expr, arms)) pos
 
+(** Import-related helper functions *)
+let detect_import_source_type file_path =
+  let extension = Filename.extension file_path in
+  match String.lowercase_ascii extension with
+  | ".ks" -> KernelScript
+  | ".py" -> Python
+  | _ -> failwith ("Unsupported import file type: " ^ extension)
+
+let make_import_declaration module_name source_path pos = {
+  module_name;
+  source_path;
+  source_type = detect_import_source_type source_path;
+  import_pos = pos;
+}
+
+let make_module_call module_name function_name args pos = {
+  module_name;
+  function_name;
+  args;
+  call_pos = pos;
+}
+
+let make_module_call_expr module_name function_name args pos =
+  make_expr (ModuleCall (make_module_call module_name function_name args pos)) pos
+
 (** Pretty-printing functions for debugging *)
 
 let string_of_position pos =
@@ -607,6 +653,11 @@ let rec string_of_expr expr =
   | TailCall (name, args) ->
       Printf.sprintf "%s(%s)" name 
         (String.concat ", " (List.map string_of_expr args))
+  | ModuleCall module_call ->
+      Printf.sprintf "%s.%s(%s)" 
+        module_call.module_name 
+        module_call.function_name
+        (String.concat ", " (List.map string_of_expr module_call.args))
   | ArrayAccess (arr, idx) ->
       Printf.sprintf "%s[%s]" (string_of_expr arr) (string_of_expr idx)
   | FieldAccess (obj, field) ->
@@ -802,6 +853,15 @@ let string_of_declaration = function
         | ImplStaticField (name, expr) -> Printf.sprintf "%s: %s," name (string_of_expr expr)
       ) impl_block.impl_items) in
       Printf.sprintf "%s impl %s {\n    %s\n}" attrs_str impl_block.impl_name items_str
+  | ImportDecl import_decl ->
+      let source_type_str = match import_decl.source_type with
+        | KernelScript -> "KernelScript"
+        | Python -> "Python"
+      in
+      Printf.sprintf "import %s from \"%s\" // %s" 
+        import_decl.module_name 
+        import_decl.source_path 
+        source_type_str
 
 let string_of_ast ast =
   String.concat "\n\n" (List.map string_of_declaration ast)

src/dune

@@ -5,7 +5,8 @@
           multi_program_analyzer multi_program_ir_optimizer ebpf_c_codegen
           userspace_codegen evaluator safety_checker stdlib test_codegen
 tail_call_analyzer kernel_module_codegen dynptr_bridge
-          btf_parser btf_binary_parser kernel_types struct_ops_registry)
+          btf_parser btf_binary_parser kernel_types struct_ops_registry
+          import_resolver python_bridge kernelscript_bridge)
  (libraries unix str kernelscript_context)
  (foreign_stubs
   (language c)

src/evaluator.ml

@@ -668,6 +668,10 @@ and eval_expression ctx expr =
       (* Tail calls are not supported in evaluation context - they only exist in eBPF *)
       eval_error ("Tail call to " ^ name ^ " cannot be evaluated in userspace context") expr.expr_pos
 
+  | ModuleCall module_call ->
+      (* Module calls are not supported in evaluation context - they need FFI setup *)
+      eval_error ("Module call to " ^ module_call.module_name ^ "." ^ module_call.function_name ^ " cannot be evaluated in userspace context") expr.expr_pos
+  
   | ArrayAccess (arr, idx) -> eval_array_access ctx arr idx expr.expr_pos
 
   | FieldAccess (obj, field) -> eval_field_access ctx obj field expr.expr_pos