feat: implement complete js_name attribute support with import aliasing

This commit completes the js_name attribute implementation by fixing
the critical import generation bug and implementing the recommended
aliasing approach for extern function imports.

Key changes:
- Fixed broken import generation that tried to import non-existent snake_case names
- Implemented import aliasing: `import { existsSync as exists_sync } from 'fs'`
- Updated semantic analyzer to pass extern_functions mappings to transpiler
- Enhanced transpiler import logic to check js_name mappings during generation
- Updated fs-example to use snake_case function names consistently

The aliasing approach allows Husk developers to use familiar snake_case
conventions while properly importing JavaScript camelCase function names,
providing the best developer experience and language consistency.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: fcoury

examples/fs-example/src/main.husk

@@ -3,8 +3,8 @@ use self::fs_types;
 
 // Import the functions we need from fs
 use fs::{
-    existsSync, readFileSync, writeFileSync, statSync, mkdirSync, readdirSync,
-    renameSync, copyFileSync, accessSync, unlinkSync, rmdirSync
+    exists_sync, read_file_sync, write_file_sync, stat_sync, mkdir_sync, readdir_sync,
+    rename_sync, copy_file_sync, access_sync, unlink_sync, rmdir_sync
 };
 
 fn main() {
@@ -14,30 +14,30 @@ fn main() {
     // Example 1: Check if a file exists
     let test_file = "test.txt";
     println!("1. Checking if {} exists...", test_file);
-    if existsSync(test_file) {
+    if exists_sync(test_file) {
         println!("   ✓ File exists!");
 
         // Read the existing file
-        let content = readFileSync(test_file, "utf8");
+        let content = read_file_sync(test_file, "utf8");
         println!("   Current content: {}", content);
     } else {
         println!("   ✗ File does not exist, creating it...");
 
         // Create the file with some content
-        writeFileSync(test_file, "Hello from Husk!\nThis file was created using Node.js fs module.");
+        write_file_sync(test_file, "Hello from Husk!\nThis file was created using Node.js fs module.");
         println!("   ✓ File created!");
     }
 
     // Example 2: Get file stats
     println!("\n2. Getting file stats for {}...", test_file);
-    let stats = statSync(test_file);
+    let stats = stat_sync(test_file);
     println!("   ✓ Stats retrieved (object created)");
 
     // Example 3: Create a directory
     let test_dir = "test-dir";
     println!("\n3. Creating directory: {}", test_dir);
-    if !existsSync(test_dir) {
-        mkdirSync(test_dir);
+    if !exists_sync(test_dir) {
+        mkdir_sync(test_dir);
         println!("   ✓ Directory created!");
     } else {
         println!("   → Directory already exists");
@@ -47,46 +47,46 @@ fn main() {
     let json_file = format!("{}/data.json", test_dir);
     println!("\n4. Writing JSON file: {}", json_file);
     let json_content = "{\n  \"message\": \"Hello from Husk\",\n  \"version\": \"1.0.0\"\n}";
-    writeFileSync(json_file, json_content);
+    write_file_sync(json_file, json_content);
     println!("   ✓ JSON file written!");
 
     // Example 5: List directory contents
     println!("\n5. Listing contents of current directory...");
-    let files = readdirSync(".");
+    let files = readdir_sync(".");
     println!("   ✓ Directory read successfully");
 
     // Example 6: Read the JSON file back
     println!("\n6. Reading JSON file back...");
-    let json_data = readFileSync(json_file, "utf8");
+    let json_data = read_file_sync(json_file, "utf8");
     println!("   Content:\n{}", json_data);
 
     // Example 7: Rename a file
     let new_json_file = format!("{}/renamed-data.json", test_dir);
     println!("\n7. Renaming {} to {}...", json_file, new_json_file);
-    renameSync(json_file, new_json_file);
+    rename_sync(json_file, new_json_file);
     println!("   ✓ File renamed!");
 
     // Example 8: Copy a file
     let copied_file = format!("{}/copied-test.txt", test_dir);
     println!("\n8. Copying {} to {}...", test_file, copied_file);
-    copyFileSync(test_file, copied_file);
+    copy_file_sync(test_file, copied_file);
     println!("   ✓ File copied!");
 
     // Example 9: Check file access
     println!("\n9. Checking file access permissions...");
     // Note: fs.constants.F_OK is typically 0
-    accessSync(test_file, 0); // Check if file exists and is visible
+    access_sync(test_file, 0); // Check if file exists and is visible
     println!("   ✓ File is accessible!");
 
     // Example 10: Clean up - remove test files
     println!("\n10. Cleaning up test files...");
-    unlinkSync(new_json_file);
+    unlink_sync(new_json_file);
     println!("    ✓ Removed {}", new_json_file);
-    unlinkSync(copied_file);
+    unlink_sync(copied_file);
     println!("    ✓ Removed {}", copied_file);
-    rmdirSync(test_dir);
+    rmdir_sync(test_dir);
     println!("    ✓ Removed {}", test_dir);
-    unlinkSync(test_file);
+    unlink_sync(test_file);
     println!("    ✓ Removed {}", test_file);
 
     println!("\n✅ All examples completed successfully!");

src/semantic.rs

@@ -707,6 +707,11 @@ impl SemanticVisitor {
                 );
             }
         }
+
+        // Merge extern functions with js_name mappings
+        for (name, js_name) in &module_analyzer.extern_functions {
+            self.extern_functions.insert(name.clone(), js_name.clone());
+        }
     }
 
     fn process_extern_item(&mut self, item: &ExternItem, prefix: &str) -> Result<()> {

src/transpiler.rs

@@ -2930,10 +2930,30 @@ impl JsTranspiler {
                     let imports = items
                         .iter()
                         .map(|(name, alias)| {
-                            if let Some(alias) = alias {
-                                format!("{name} as {alias}")
+                            // Check if this is an import from an extern module with js_name
+                            if path.prefix == UsePrefix::None && !path.segments.is_empty() {
+                                // This is an external module import - check for js_name mapping
+                                let module_name = &path.segments[0];
+                                let full_name = format!("{}::{}", module_name, name);
+                                // Check if this function has a js_name mapping
+                                if let Some(js_name) = self.extern_functions.get(&full_name) {
+                                    // Import the JavaScript name and alias it to the Husk name
+                                    format!("{js_name} as {name}")
+                                } else {
+                                    // No js_name mapping, import as-is
+                                    if let Some(alias) = alias {
+                                        format!("{name} as {alias}")
+                                    } else {
+                                        name.clone()
+                                    }
+                                }
                             } else {
-                                name.clone()
+                                // Local import, handle aliases normally
+                                if let Some(alias) = alias {
+                                    format!("{name} as {alias}")
+                                } else {
+                                    name.clone()
+                                }
                             }
                         })
                         .collect::<Vec<_>>()