gh-121: Fix module aliasing.

Author: python-processing-unit

src/builtins.c

@@ -6245,16 +6245,33 @@ static Value builtin_export(Interpreter* interp, Value* args, int argc, Expr** a
         RUNTIME_ERROR(interp, "EXPORT failed to assign into module", line, col);
     }
 
-    // Also create qualified name in caller env: module.symbol
-    size_t len = strlen(module) + 1 + strlen(sym) + 1;
-    char* qualified = malloc(len);
-    if (!qualified) RUNTIME_ERROR(interp, "Out of memory", line, col);
-    snprintf(qualified, len, "%s.%s", module, sym);
-    if (!env_assign(env, qualified, entry->value, entry->decl_type, true)) {
+    /* Materialize qualified bindings for every registered alias that
+       references the same module environment. This ensures EXPORT updates
+       sibling aliases that point at the same module (per spec). */
+    size_t alias_count = 0;
+    char** aliases = module_list_aliases(interp, mod_env, &alias_count);
+    if (aliases) {
+        for (size_t ai = 0; ai < alias_count; ai++) {
+            if (module_export_bindings(interp, env, mod_env, aliases[ai], line, col, "EXPORT failed to assign qualified name") != 0) {
+                for (size_t j = 0; j < alias_count; j++) free(aliases[j]);
+                free(aliases);
+                RUNTIME_ERROR(interp, "EXPORT failed to assign qualified name", line, col);
+            }
+            free(aliases[ai]);
+        }
+        free(aliases);
+    } else {
+        /* Fallback to previous behavior if alias enumeration fails */
+        size_t len = strlen(module) + 1 + strlen(sym) + 1;
+        char* qualified = malloc(len);
+        if (!qualified) RUNTIME_ERROR(interp, "Out of memory", line, col);
+        snprintf(qualified, len, "%s.%s", module, sym);
+        if (!env_assign(env, qualified, entry->value, entry->decl_type, true)) {
+            free(qualified);
+            RUNTIME_ERROR(interp, "EXPORT failed to assign qualified name", line, col);
+        }
         free(qualified);
-        RUNTIME_ERROR(interp, "EXPORT failed to assign qualified name", line, col);
     }
-    free(qualified);
 
     return value_bool(false);
 }
@@ -7487,6 +7504,12 @@ static Value builtin_import(Interpreter* interp, Value* args, int argc, Expr** a
     if (found_path && strcmp(found_path, cache_key) != 0) {
         (void)module_register_alias(interp, found_path, mod_env);
     }
+    /* Also register the caller-provided alias (if different) so callers can
+       refer to the module by that identifier. IMPORT_PATH does this earlier;
+       ensure builtin IMPORT behaves the same. */
+    if (alias && strcmp(alias, cache_key) != 0) {
+        (void)module_register_alias(interp, alias, mod_env);
+    }
 
     EnvEntry* scope_entry = env_get_entry(mod_env, "__MODULE_SCOPE__");
     if (!scope_entry || !scope_entry->initialized || scope_entry->value.type != VAL_STR) {

src/interpreter.c

@@ -724,6 +724,37 @@ Env* module_env_lookup(Interpreter* interp, const char* name) {
     return NULL;
 }
 
+char** module_list_aliases(Interpreter* interp, Env* env, size_t* out_count) {
+    if (out_count) *out_count = 0;
+    if (!interp || !env) return NULL;
+    size_t count = 0;
+    ModuleEntry* e = interp->modules;
+    while (e) {
+        if (e->env == env) count++;
+        e = e->next;
+    }
+    if (count == 0) return NULL;
+    char** arr = malloc(sizeof(char*) * count);
+    if (!arr) return NULL;
+    e = interp->modules;
+    size_t idx = 0;
+    while (e) {
+        if (e->env == env) {
+            arr[idx] = strdup(e->name);
+            if (!arr[idx]) {
+                for (size_t j = 0; j < idx; j++) free(arr[j]);
+                free(arr);
+                if (out_count) *out_count = 0;
+                return NULL;
+            }
+            idx++;
+        }
+        e = e->next;
+    }
+    if (out_count) *out_count = idx;
+    return arr;
+}
+
 // ============ Value truthiness ============
 
 int value_truthiness(Value v) {

src/interpreter.h

@@ -150,5 +150,9 @@ int module_register(Interpreter* interp, const char* name);
 int module_register_alias(Interpreter* interp, const char* name, Env* env);
 // Lookup a module's Env by name; returns NULL if not found.
 Env* module_env_lookup(Interpreter* interp, const char* name);
+// Return a newly-allocated array of alias names (caller must free each string
+// and the returned array) for the given module Env. `out_count` receives the
+// number of aliases. Returns NULL when there are no aliases or on error.
+char** module_list_aliases(Interpreter* interp, Env* env, size_t* out_count);
 
 #endif // INTERPRETER_H