gh-191: Make EXTEND use STR.

Closes #191.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -647,7 +647,7 @@
 
 The interpreter MUST NOT load `.prex` pointer files.
 
-Runtime extension loading from Prefix source MUST use `EXTEND(EXTENSION ext)`, defined in [9.1.8](#918-function-and-module-operators). The `ext` specifier MUST exclude the platform filename suffix (`.dll`, `.so`, `.dylib`) and MAY use package semantics with `..`. When `ext` names a package, the loader MUST attempt `ext..init`.
+Runtime extension loading from Prefix source MUST use `EXTEND(STR ext)`, defined in [9.1.8](#918-function-and-module-operators). The `ext` specifier MUST exclude the platform filename suffix (`.dll`, `.so`, `.dylib`) and MAY use package semantics with `..`. When `ext` names a package, the loader MUST attempt `ext..init`.
 
 `EXTEND` MUST resolve extension libraries using the same extension search roots used by compiled-library loading: the calling module directory when available, then current working directory, then interpreter `ext/std`, `ext/usr`, `lib/std`, and `lib/usr` roots with bundled roots consulted before user roots.
 
@@ -687,8 +687,6 @@
 
 `MODULE` is a pseudo-type indicating that the argument MUST be a plain unquoted module identifier or a package-qualified module name using the language's `..` separator. A comma-separated signature such as `+, -, *` denotes a family of distinct operators that share the same argument rules and differ only in the named operation.
 
-`EXTENSION` is a pseudo-type indicating that the argument MUST be a plain unquoted extension specifier used by `EXTEND`, excluding the platform filename suffix and optionally using package-style `..` separators.
-
 `INT` and `FLT` are not interoperable. Unless an operator explicitly permits or requires type mixing, all numeric operands MUST share the same numeric type; supplying mismatched types MUST raise a runtime error. The numeric base of an operation's result MUST be the highest base present among its numeric operands.
 
 Built-in operator names MUST be matched case-sensitively and MUST be written in their canonical form. A user-defined function MUST NOT share a name with any built-in operator; such a conflict MUST raise a runtime error. Extensions MAY register additional operators, which are dispatched through the same call syntax and MAY be qualified with a dotted extension-name prefix, but whose names MUST NOT conflict with those of built-in operators.
@@ -847,7 +845,7 @@
 
 - `BOOL MAIN()` = MUST return `TRUE` when the call site is in the primary program source and `FALSE` when the call site is executing from imported module code. The result MUST depend on the source location of the call expression rather than on the dynamic caller stack.
 
-- `BOOL EXTEND(EXTENSION ext)` = MUST load the compiled extension designated by `ext`. The specifier `ext` MUST exclude the platform filename suffix and MAY use package-style `..` separators. If `ext` resolves to a package, the loader MUST attempt `ext..init`. Relative extension names MUST resolve using the calling module's source directory when available, then the current working directory, then the configured extension roots `ext/std`, `ext/usr`, `lib/std`, and `lib/usr` (with bundled roots searched before user roots). Repeating an `EXTEND` request for an already-loaded extension exposure MUST be idempotent. On success, `EXTEND` MUST return `FALSE`.
+-- `BOOL EXTEND(STR ext)` = MUST load the compiled extension designated by `ext`. The specifier `ext` MUST exclude the platform filename suffix and MAY use package-style `..` separators. If `ext` resolves to a package, the loader MUST attempt `ext..init`. Relative extension names MUST resolve using the calling module's source directory when available, then the current working directory, then the configured extension roots `ext/std`, `ext/usr`, `lib/std`, and `lib/usr` (with bundled roots searched before user roots). Repeating an `EXTEND` request for an already-loaded extension exposure MUST be idempotent. On success, `EXTEND` MUST return `FALSE`.
 
   Operators registered with the module-restriction flag (for example `PREFIX_EXTENSION_MODULE_RESTRICTED`) MUST be exposed only under the extending module's namespace. Importing that module MUST expose the extension namespace qualifier under the importing module's qualified name. `PREFIX_EXTENSION_ASMODULE` by itself MUST NOT restrict an operator to the extending module's namespace or cause that qualified exposure. Extension side effects outside operator registration (for example process-global hooks or host-side state) remain global.
 

lib/std/gui/init.pre

@@ -1,6 +1,6 @@
 ! `image`-interoperable GUI operations for Prefix
 
-EXTEND(EXTENSION: gui)
+EXTEND("gui")
 
 FUNC INT SCREEN_WIDTH(){
     RETURN(SCREEN()[0d1])

lib/std/image/init.pre

@@ -4,9 +4,9 @@
 ! The returned tensor layout is [column][row][channel] (width, height, channel)
 ! in user code. Channels are ordered r, g, b, a and values are 0..255.
 
-EXTEND(EXTENSION: win32)
+EXTEND("win32")
 
-EXTEND(EXTENSION: image)
+EXTEND("image")
 
 IMPORT("path")
 

src/builtins.c

@@ -9736,20 +9736,15 @@ static Value builtin_exit(Interpreter *interp, Value *args, int argc, Expr **arg
 }
 
 static Value builtin_extend(Interpreter *interp, Value *args, int argc, Expr **arg_nodes, Env *env, int line, int col) {
-    if (argc < 1 || !arg_nodes || !arg_nodes[0]) {
-        RUNTIME_ERROR(interp, "EXTEND expects EXTENSION: name", line, col);
+    (void)arg_nodes;
+
+    if (argc < 1 || !args) {
+        RUNTIME_ERROR(interp, "EXTEND expects STR argument", line, col);
     }
 
-    const char *spec = NULL;
-    Expr *spec_node = arg_nodes[0];
+    EXPECT_STR(args[0], "EXTEND", interp, line, col);
 
-    if (spec_node->type == EXPR_TYPED_IDENT) {
-        spec = spec_node->as.typed_ident.name;
-    } else if (spec_node->type == EXPR_IDENT) {
-        spec = spec_node->as.ident;
-    } else if (args && args[0].type == VAL_STR) {
-        spec = args[0].as.s;
-    }
+    const char *spec = args[0].as.s;
 
     if (!spec || spec[0] == '\0') {
         RUNTIME_ERROR(interp, "EXTEND expects a non-empty extension specifier", line, col);

src/interpreter.c

@@ -1406,10 +1406,6 @@ Value eval_expr(Interpreter *interp, Expr *expr, Env *env) {
                             deferred_async_arg0 = true;
                             continue;
                         }
-                        if (strcmp(func_name, "EXTEND") == 0 && i == 0 && arg_expr->type == EXPR_TYPED_IDENT) {
-                            // EXTEND(EXTENSION: name) passes the symbolic extension specifier.
-                            continue;
-                        }
                         if ((strcmp(func_name, "DEL") == 0 || strcmp(func_name, "EXIST") == 0 ||
                              strcmp(func_name, "ASSIGN") == 0) &&
                             i == 0) {

src/parser.c

@@ -556,72 +556,6 @@ static Expr *parse_typed_ident_expr(Parser *parser) {
     return expr_typed_ident(dtype, name, type_tok.line, type_tok.column);
 }
 
-static Expr *parse_extension_spec_expr(Parser *parser) {
-    Token type_tok = parser->current_token;
-
-    if (type_tok.type == TOKEN_IDENT && type_tok.literal && strcmp(type_tok.literal, "EXTENSION") == 0 &&
-        parser->next_token.type == TOKEN_COLON) {
-        advance(parser);
-        consume(parser, TOKEN_COLON, "Expected ':' after EXTENSION");
-
-        if (parser->current_token.type != TOKEN_IDENT) {
-            report_error(parser, "Expected extension specifier after EXTENSION:");
-            return NULL;
-        }
-    } else if (parser->current_token.type != TOKEN_IDENT) {
-        report_error(parser, "Expected extension specifier");
-        return NULL;
-    }
-
-    char *name = parser->current_token.literal;
-    advance(parser);
-
-    while (parser->current_token.type == TOKEN_DOT) {
-        advance(parser); // consume first dot
-
-        int is_package_sep = 0;
-        if (parser->current_token.type == TOKEN_DOT) {
-            is_package_sep = 1;
-            advance(parser); // consume second dot
-        }
-
-        if (parser->current_token.type != TOKEN_IDENT) {
-            report_error(parser, "Expected identifier after extension separator");
-            return NULL;
-        }
-
-        const char *part = parser->current_token.literal;
-        size_t cur_len = strlen(name);
-        size_t part_len = strlen(part);
-        size_t sep_len = is_package_sep ? 2 : 1;
-        size_t new_len = cur_len + sep_len + part_len + 1;
-        char *tmp = realloc(name, new_len);
-        if (!tmp) {
-            fprintf(stderr, "Out of memory\n");
-            exit(1);
-        }
-        name = tmp;
-        if (is_package_sep) {
-            name[cur_len] = '.';
-            name[cur_len + 1] = '.';
-            if (part_len) {
-                memcpy(name + cur_len + 2, part, part_len);
-            }
-            name[cur_len + 2 + part_len] = '\0';
-        } else {
-            name[cur_len] = '.';
-            if (part_len) {
-                memcpy(name + cur_len + 1, part, part_len);
-            }
-            name[cur_len + 1 + part_len] = '\0';
-        }
-
-        advance(parser);
-    }
-
-    return expr_typed_ident(TYPE_UNKNOWN, name, type_tok.line, type_tok.column);
-}
-
 static Expr *parse_primary(Parser *parser) {
     Token token = parser->current_token;
     // Recognize FLT literal names `INF` and `NaN` as primary expressions
@@ -830,15 +764,8 @@ static Expr *parse_call(Parser *parser) {
                          call->as.call.kw_count == 0 && is_type_token(parser->current_token.type) &&
                          (parser->next_token.type == TOKEN_IDENT || parser->next_token.type == TOKEN_COLON)) != 0;
 
-                    bool is_extend_specifier =
-                        (call->as.call.callee->type == EXPR_IDENT &&
-                         strcmp(call->as.call.callee->as.ident, "EXTEND") == 0 && call->as.call.args.count == 0 &&
-                         call->as.call.kw_count == 0 && parser->current_token.type == TOKEN_IDENT &&
-                         parser->next_token.type != TOKEN_EQUALS) != 0;
-
-                    if (is_typed_assign_target || is_extend_specifier) {
-                        Expr *arg = (int)is_extend_specifier ? parse_extension_spec_expr(parser)
-                                                             : parse_typed_ident_expr(parser);
+                    if (is_typed_assign_target) {
+                        Expr *arg = parse_typed_ident_expr(parser);
                         if (!arg) {
                             return NULL;
                         }

tests/cases/failing/extend-missing-file.pre

@@ -1 +1 @@
-EXTEND(prefix_missing_extension_target)
+EXTEND("prefix_missing_extension_target")

tests/cases/passing/extend-explicit-suffix-rejected.ps1

@@ -13,7 +13,7 @@ try {
   Copy-Item -Path $coreExtension -Destination $stagedExtension -Force
 
   Set-Content -Path $programPath -Encoding Ascii -Value @"
-BOOL loaded = EXTEND($extensionSpecifier)
+BOOL loaded = EXTEND("$extensionSpecifier")
 REFUTE(loaded)
 "@
 

tests/cases/passing/extend-search-cwd-before-roots.ps1

@@ -28,7 +28,7 @@ try {
   Add-StagedProbe $libStdProbe
   Add-StagedProbe $libUsrProbe
 
-  $sourceText = 'BOOL loaded=EXTEND(search_probe);REFUTE(loaded);PRINT(TST_SEARCH_PROBE_PATH())'
+  $sourceText = 'BOOL loaded=EXTEND("search_probe");REFUTE(loaded);PRINT(TST_SEARCH_PROBE_PATH())'
   $result = Invoke-PrefixWithArguments -Arguments @('-source', $sourceText) -WorkingDirectory $cwdDir
   Assert-PrefixSuccess $result
   Assert-NoErrorOutput $result

tests/cases/passing/extend-search-ext-std-before-ext-usr.ps1

@@ -25,7 +25,7 @@ try {
   Add-StagedProbe $libUsrProbe
 
   Set-Content -Path $programPath -Encoding Ascii -Value @'
-BOOL loaded = EXTEND(search_probe)
+BOOL loaded = EXTEND("search_probe")
 REFUTE(loaded)
 PRINT(TST_SEARCH_PROBE_PATH())
 '@