gh-21: Add module aliasing.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -826,8 +826,6 @@
 
   Package imports: Prefix supports package namespaces using `..` as the package separator. The canonical form is `package..subpackage..module`. When `IMPORT(pkg)` is used the interpreter will prefer a package layout and attempt to load `pkg/init.pre` from the referring source's directory (falling back to the interpreter `lib/` directory). If a directory named `pkg` exists but contains no `init.pre` the import raises a clear error. When `IMPORT(pkg..mod)` is used the interpreter resolves to `pkg/mod.pre` (or the corresponding file under `lib/`). When a package directory and a same-named module file both exist in the same search location, the package takes precedence. Items within the package are still imported using their full dotted names (for example, `pkg..mod.FOO`).
 
-- `IMPORT_PATH(STR: path)` - Loads a Prefix module from the absolute filesystem `path` provided as a `STR`. The argument must be an absolute path to a `.pre` source file. The imported module is treated the same as `IMPORT` with respect to parsing, execution isolation, function/module caching, and companion extension loading (companion `<module>.prex` alongside the resolved file and a built-in `ext/<module>.py` are both checked and loaded if present). The module's basename (filename without extension) is used as the module identifier for qualifying exported bindings.
-
   The first argument must be an identifier naming a module; the interpreter first looks for a file named `<name>.pre` in the same directory as the referring source file. When the referring source is provided via the `-source` string literal mode, the primary search directory is the process's current working directory. If the module file is not found there, the interpreter will additionally attempt to load the file from a `lib` subdirectory located alongside the interpreter implementation (that is, `<interpreter_dir>/lib/<name>.pre`, where `<interpreter_dir>` is the directory containing the interpreter script or executable).
 
   The imported file is parsed and executed in its own isolated top-level environment on the first import during a given interpreter invocation: top-level assignments and function definitions in the imported module do not directly mutate the caller's environment during execution. During that execution unqualified identifiers (for example, `x` or `helper`) refer to names in the module's own top-level namespace. Qualified identifiers (for example, `other.FOO`) refer only to the dotted names that the module itself has created or imported; those qualified bindings are scoped to the module's namespace.
@@ -838,6 +836,9 @@
 
   When a module is imported, the interpreter also attempts to load any associated runtime extensions so their operators are immediately available to the importer. The interpreter first looks for a companion pointer file named `<module>.prex` next to the resolved module file (or in the interpreter `lib/` fallback) and loads any extensions listed there. If no pointer file is present (or as an additional fallback), the interpreter will also check its built-in `ext/` directory for a single-file extension named `<module>.py` and load it if present. Operators registered by such extensions are attached to the running interpreter at import time and become callable (typically under the module-qualified names they register).
 
+
+- `IMPORT_PATH(STR: path)` - Loads a Prefix module from the absolute filesystem `path` provided as a `STR`. The argument must be an absolute path to a `.pre` source file. The imported module is treated the same as `IMPORT` with respect to parsing, execution isolation, function/module caching, and companion extension loading (companion `<module>.prex` alongside the resolved file and a built-in `ext/<module>.py` are both checked and loaded if present). The module's basename (filename without extension) is used as the module identifier for qualifying exported bindings.
+
 - `EXPORT(SYMBOL: symbol, MODULE: module):INT` - Adds the caller's binding for the identifier `symbol` into the namespace of the imported module named by the identifier `module`. The first argument must be an identifier (not a string literal); its current value in the caller's environment is copied into the imported module's namespace and becomes available as the qualified name `module.symbol` in the caller's environment. The second argument must be an identifier naming a previously-imported module; if the module has not been imported yet, the interpreter raises a runtime error (rewrite: EXPORT). `EXPORT` returns `INT` 0 on success.
 
 ### 12.16 File operations:

src/builtins.c

@@ -4251,6 +4251,11 @@ static Value builtin_import_path(Interpreter* interp, Value* args, int argc, Exp
     if (found_path && strcmp(found_path, cache_key) != 0) {
         (void)module_register_alias(interp, found_path, mod_env);
     }
+    // Register provided alias name in module registry so callers can
+    // refer to the module by that identifier (EXPORT relies on this).
+    if (alias && strcmp(alias, cache_key) != 0) {
+        (void)module_register_alias(interp, alias, mod_env);
+    }
 
     // If not already loaded, execute module source once.
     EnvEntry* marker = env_get_entry(mod_env, "__MODULE_LOADED__");
@@ -4332,10 +4337,14 @@ static Value builtin_import_path(Interpreter* interp, Value* args, int argc, Exp
         }
         if (!belongs) continue;
 
-        size_t qlen = alias_len + 1 + strlen(fe->name) + 1;
+        const char* fname = fe->name ? fe->name : "";
+        const char* unq = strchr(fname, '.');
+        if (unq) unq = unq + 1; else unq = fname;
+
+        size_t qlen = alias_len + 1 + strlen(unq) + 1;
         char* qualified = malloc(qlen);
         if (!qualified) { RUNTIME_ERROR(interp, "Out of memory", line, col); }
-        snprintf(qualified, qlen, "%s.%s", alias, fe->name);
+        snprintf(qualified, qlen, "%s.%s", alias, unq);
         Value fv = value_func(fe->func);
 
         // Try to assign qualified symbol into caller env
@@ -6208,10 +6217,14 @@ static Value builtin_import(Interpreter* interp, Value* args, int argc, Expr** a
         }
         if (!belongs) continue;
 
-        size_t qlen = alias_len + 1 + strlen(fe->name) + 1;
+        const char* fname = fe->name ? fe->name : "";
+        const char* unq = strchr(fname, '.');
+        if (unq) unq = unq + 1; else unq = fname;
+
+        size_t qlen = alias_len + 1 + strlen(unq) + 1;
         char* qualified = malloc(qlen);
         if (!qualified) { RUNTIME_ERROR(interp, "Out of memory", line, col); }
-        snprintf(qualified, qlen, "%s.%s", alias, fe->name);
+        snprintf(qualified, qlen, "%s.%s", alias, unq);
         Value fv = value_func(fe->func);
         if (!env_assign(env, qualified, fv, TYPE_FUNC, true)) {
             value_free(fv);

src/interpreter.c

@@ -568,7 +568,7 @@ Value eval_expr(Interpreter* interp, Expr* expr, Env* env) {
                         for (int i = 0; i < pos_argc; i++) {
                             arg_nodes[i] = expr->as.call.args.items[i];
                             if (((strcmp(func_name, "DEL") == 0 || strcmp(func_name, "EXIST") == 0 || strcmp(func_name, "IMPORT") == 0 || strcmp(func_name, "ASSIGN") == 0) && i == 0)
-                                || (strcmp(func_name, "IMPORT_PATH") == 0 && i == 1)) {
+                                || ((strcmp(func_name, "IMPORT") == 0 || strcmp(func_name, "IMPORT_PATH") == 0) && i == 1)) {
                                 // leave as null placeholder
                                 continue;
                             }