fix: resolve extern function linking and ZRTL signature issues

- lowering.rs: propagate link_name from TypedFunction to HirFunction
- cranelift_backend: use link_name when declaring extern function imports
- grammar2.rs: change debug output to log::debug/warn
- zrtl_image: add function signatures for all exported symbols
- zrtl_io: add signatures for string print functions (i64 -> void)
- imagepipe.zyn: use $IO$println for string literal printing

Author: darmie

crates/compiler/src/cranelift_backend.rs

@@ -351,8 +351,14 @@ impl CraneliftBackend {
 
         if function.is_external {
             // External functions use Import linkage
-            let link_name = function.name.resolve_global()
-                .unwrap_or_else(|| format!("{:?}", function.name));
+            // Use link_name if specified (maps alias to actual symbol, e.g., "image_load" -> "$Image$load")
+            // Otherwise fall back to function name
+            let link_name = function.link_name.as_ref()
+                .map(|s| s.clone())
+                .unwrap_or_else(|| {
+                    function.name.resolve_global()
+                        .unwrap_or_else(|| format!("{:?}", function.name))
+                });
             let func_id = self.module.declare_function(
                 &link_name,
                 Linkage::Import,

crates/compiler/src/lowering.rs

@@ -883,6 +883,14 @@ impl LoweringContext {
             // Set calling convention
             hir_func.calling_convention = self.convert_calling_convention(func.calling_convention);
 
+            // Set link_name if specified (maps alias to actual symbol)
+            // e.g., "image_load" -> "$Image$load"
+            if let Some(ref link_name) = func.link_name {
+                let link_name_str = link_name.resolve_global()
+                    .unwrap_or_else(|| link_name.to_string());
+                hir_func.link_name = Some(link_name_str);
+            }
+
             // Extern functions have no body - clear the default entry block
             hir_func.blocks.clear();
 

crates/zyntax_embed/src/grammar2.rs

@@ -143,12 +143,17 @@ impl Grammar2 {
         let mut program = self.parse_with_filename(source, filename)?;
 
         // Inject extern function declarations for builtins
+        // This adds both alias names (e.g., image_load) and symbol names (e.g., $Image$load)
         self.inject_builtin_externs(&mut program, Some(signatures))?;
 
         Ok(program)
     }
 
     /// Inject extern function declarations for all builtins from @builtin directive
+    ///
+    /// Creates TWO extern declarations for each builtin:
+    /// 1. The alias name (e.g., `image_load`) with link_name pointing to symbol
+    /// 2. The symbol name (e.g., `$Image$load`) for direct calls
     fn inject_builtin_externs(
         &self,
         program: &mut TypedProgram,
@@ -160,22 +165,32 @@ impl Grammar2 {
 
         // Iterate over all builtins from @builtin directive
         for (source_name, target_symbol) in &self.grammar.builtins.functions {
+            log::debug!("[Grammar2] Processing builtin: {} -> {}", source_name, target_symbol);
+
             // Get return type from @types.function_returns if available
             let return_type = if let Some(type_str) = self.grammar.type_decls.function_returns.get(source_name) {
+                log::debug!("[Grammar2] Found @types.function_returns for {}: {}", source_name, type_str);
                 Type::Extern {
                     name: InternedString::new_global(type_str),
                     layout: None,
                 }
             } else if let Some(sigs) = signatures {
-                sigs.get(target_symbol.as_str())
-                    .map(|sig| Self::type_tag_to_type(&sig.return_type))
-                    .unwrap_or(Type::Any)
+                if let Some(sig) = sigs.get(target_symbol.as_str()) {
+                    log::debug!("[Grammar2] Found ZRTL signature for {}: params={}, return={:?}",
+                        target_symbol, sig.param_count, sig.return_type);
+                    Self::type_tag_to_type(&sig.return_type)
+                } else {
+                    log::warn!("[Grammar2] No ZRTL signature found for {}, using Type::Any. Available keys: {:?}",
+                        target_symbol, sigs.keys().collect::<Vec<_>>());
+                    Type::Any
+                }
             } else {
+                log::debug!("[Grammar2] No signatures provided, using Type::Any");
                 Type::Any
             };
 
             // Get parameters from signature if available
-            let params = if let Some(sigs) = signatures {
+            let params: Vec<TypedParameter> = if let Some(sigs) = signatures {
                 if let Some(sig) = sigs.get(target_symbol.as_str()) {
                     (0..sig.param_count)
                         .map(|i| {
@@ -198,26 +213,47 @@ impl Grammar2 {
                 vec![]
             };
 
-            // Create extern function declaration
-            let extern_func = TypedFunction {
-                name: InternedString::new_global(target_symbol),
+            // 1. Create alias extern (e.g., image_load -> links to $Image$load)
+            // This is what the grammar's generated AST calls
+            let alias_func = TypedFunction {
+                name: InternedString::new_global(source_name),
                 type_params: vec![],
-                params,
-                return_type,
+                params: params.clone(),
+                return_type: return_type.clone(),
                 body: None,
                 visibility: Visibility::Public,
                 is_async: false,
                 is_external: true,
                 calling_convention: CallingConvention::Default,
                 link_name: Some(InternedString::new_global(target_symbol)),
             };
-
-            // Add to program declarations
             program.declarations.push(typed_node(
-                TypedDeclaration::Function(extern_func),
+                TypedDeclaration::Function(alias_func),
                 Type::Primitive(PrimitiveType::Unit),
                 span,
             ));
+
+            // 2. Create symbol extern (e.g., $Image$load) for direct calls
+            // Skip if source_name == target_symbol (avoid duplicates)
+            if source_name != target_symbol {
+                let symbol_func = TypedFunction {
+                    name: InternedString::new_global(target_symbol),
+                    type_params: vec![],
+                    params,
+                    return_type,
+                    body: None,
+                    visibility: Visibility::Public,
+                    is_async: false,
+                    is_external: true,
+                    calling_convention: CallingConvention::Default,
+                    link_name: Some(InternedString::new_global(target_symbol)),
+                };
+                program.declarations.push(typed_node(
+                    TypedDeclaration::Function(symbol_func),
+                    Type::Primitive(PrimitiveType::Unit),
+                    span,
+                ));
+            }
         }
 
         Ok(())

examples/imagepipe/imagepipe.zyn

@@ -35,6 +35,7 @@
     image_invert: "$Image$invert",
 
     // Console output (zrtl_io)
+    // Use println which takes StringConstPtr for string literals
     println: "$IO$println",
 }
 

plugins/zrtl_image/src/lib.rs

@@ -690,44 +690,74 @@ pub extern "C" fn image_invert(handle: u64) -> u64 {
 zrtl_plugin! {
     name: "zrtl_image",
     symbols: [
-        // Loading/Saving
-        ("$Image$load", image_load),
-        ("$Image$load_bytes", image_load_bytes),
-        ("$Image$load_bytes_format", image_load_bytes_format),
-        ("$Image$save", image_save),
-        ("$Image$save_format", image_save_format),
-        ("$Image$encode", image_encode),
-        ("$Image$encode_png", image_encode_png),
-        ("$Image$encode_jpeg", image_encode_jpeg),
-
-        // Creation/Info
-        ("$Image$create", image_create),
+        // Loading/Saving (with signatures)
+        // Functions with opaque params (StringPtr/ArrayPtr) use dynamic boxing
+        // image_load(path: StringPtr) -> u64 (handle)
+        ("$Image$load", image_load, dynamic(1) -> void),
+        // image_load_bytes(data: ArrayPtr) -> u64
+        ("$Image$load_bytes", image_load_bytes, dynamic(1) -> void),
+        // image_load_bytes_format(data: ArrayPtr, format: i32) -> u64
+        ("$Image$load_bytes_format", image_load_bytes_format, dynamic(2) -> void),
+        // image_save(handle: u64, path: StringPtr) -> void
+        ("$Image$save", image_save, dynamic(2) -> void),
+        // image_save_format(handle: u64, path: StringPtr, format: i32) -> i32
+        ("$Image$save_format", image_save_format, dynamic(3) -> void),
+        // image_encode(handle: u64, format: i32) -> ArrayPtr
+        ("$Image$encode", image_encode, dynamic(2) -> dynamic),
+        // image_encode_png(handle: u64) -> ArrayPtr
+        ("$Image$encode_png", image_encode_png, dynamic(1) -> dynamic),
+        // image_encode_jpeg(handle: u64, quality: u8) -> ArrayPtr
+        ("$Image$encode_jpeg", image_encode_jpeg, dynamic(2) -> dynamic),
+
+        // Creation/Info (with signatures)
+        // image_create(width: u32, height: u32) -> u64
+        ("$Image$create", image_create, (u32, u32) -> u64),
+        // image_create_filled(width: u32, height: u32, color: Color) -> u64
+        // Note: Color is a struct, no signature for now
         ("$Image$create_filled", image_create_filled),
-        ("$Image$free", image_free),
-        ("$Image$clone", image_clone),
-        ("$Image$width", image_width),
-        ("$Image$height", image_height),
-
-        // Pixel operations
+        // image_free(handle: u64) -> void
+        ("$Image$free", image_free, (u64) -> void),
+        // image_clone(handle: u64) -> u64
+        ("$Image$clone", image_clone, (u64) -> u64),
+        // image_width(handle: u64) -> u32
+        ("$Image$width", image_width, (u64) -> u32),
+        // image_height(handle: u64) -> u32
+        ("$Image$height", image_height, (u64) -> u32),
+
+        // Pixel operations (some without signatures due to struct params)
         ("$Image$get_pixel", image_get_pixel),
         ("$Image$set_pixel", image_set_pixel),
-        ("$Image$get_pixels", image_get_pixels),
+        // image_get_pixels(handle: u64) -> ArrayPtr
+        ("$Image$get_pixels", image_get_pixels, dynamic(1) -> dynamic),
         ("$Image$set_pixels", image_set_pixels),
 
-        // Manipulation
-        ("$Image$resize", image_resize),
-        ("$Image$resize_fit", image_resize_fit),
-        ("$Image$crop", image_crop),
-        ("$Image$rotate90", image_rotate90),
-        ("$Image$rotate180", image_rotate180),
-        ("$Image$rotate270", image_rotate270),
-        ("$Image$flip_horizontal", image_flip_horizontal),
-        ("$Image$flip_vertical", image_flip_vertical),
-        ("$Image$grayscale", image_grayscale),
-        ("$Image$blur", image_blur),
-        ("$Image$brighten", image_brighten),
-        ("$Image$contrast", image_contrast),
-        ("$Image$invert", image_invert),
+        // Manipulation (with signatures)
+        // image_resize(handle: u64, width: u32, height: u32) -> u64
+        ("$Image$resize", image_resize, (u64, u32, u32) -> u64),
+        // image_resize_fit(handle: u64, max_width: u32, max_height: u32) -> u64
+        ("$Image$resize_fit", image_resize_fit, (u64, u32, u32) -> u64),
+        // image_crop(handle: u64, x: u32, y: u32, width: u32, height: u32) -> u64
+        ("$Image$crop", image_crop, (u64, u32, u32, u32, u32) -> u64),
+        // image_rotate90(handle: u64) -> u64
+        ("$Image$rotate90", image_rotate90, (u64) -> u64),
+        // image_rotate180(handle: u64) -> u64
+        ("$Image$rotate180", image_rotate180, (u64) -> u64),
+        // image_rotate270(handle: u64) -> u64
+        ("$Image$rotate270", image_rotate270, (u64) -> u64),
+        // image_flip_horizontal(handle: u64) -> u64
+        ("$Image$flip_horizontal", image_flip_horizontal, (u64) -> u64),
+        // image_flip_vertical(handle: u64) -> u64
+        ("$Image$flip_vertical", image_flip_vertical, (u64) -> u64),
+        // image_grayscale(handle: u64) -> u64
+        ("$Image$grayscale", image_grayscale, (u64) -> u64),
+        // image_blur(handle: u64, sigma: f32) -> u64
+        ("$Image$blur", image_blur, (u64, f32) -> u64),
+        // image_brighten(handle: u64, value: i32) -> u64
+        ("$Image$brighten", image_brighten, (u64, i32) -> u64),
+        // image_contrast(handle: u64, value: f32) -> u64
+        ("$Image$contrast", image_contrast, (u64, f32) -> u64),
+        // image_invert(handle: u64) -> u64
+        ("$Image$invert", image_invert, (u64) -> u64),
     ]
 }
 

plugins/zrtl_io/src/lib.rs

@@ -839,11 +839,11 @@ pub unsafe extern "C" fn io_string_concat(a: StringConstPtr, b: StringConstPtr)
 zrtl_plugin! {
     name: "zrtl_io",
     symbols: [
-        // String output (ZRTL string format)
-        ("$IO$print", io_print),
-        ("$IO$println", io_println),
-        ("$IO$eprint", io_eprint),
-        ("$IO$eprintln", io_eprintln),
+        // String output (ZRTL string format) - takes StringConstPtr (i64 pointer)
+        ("$IO$print", io_print, (i64) -> void),
+        ("$IO$println", io_println, (i64) -> void),
+        ("$IO$eprint", io_eprint, (i64) -> void),
+        ("$IO$eprintln", io_eprintln, (i64) -> void),
 
         // Primitive output
         ("$IO$print_i64", io_print_i64),