gh-194: Make EXIST use STR.

Closes #194.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -701,7 +701,7 @@
 
 - `ANY ASSIGN(target, ANY value)` = MUST evaluate `value`, assign it to `target`, and return the assigned value. `target` MAY be a plain identifier, a tensor indexed target, or a map indexed target. If a plain identifier has not yet been declared, the typed form `ASSIGN(TYPE name, value)` MUST be used. The typed form MUST NOT be used with indexed targets.
 
-- `BOOL EXIST(SYMBOL name)` = MUST return `TRUE` if `name` resolves to a visible readable binding in the current lexical environment chain and `FALSE` otherwise.
+- `BOOL EXIST(STR name)` = MUST evaluate `name`, require the result to be a `STR`, and return `TRUE` if that string's contents resolve to a visible readable binding in the current lexical environment chain and `FALSE` otherwise.
 
 - `BOOL ISBOOL/ISINT/ISFLT/ISSTR/ISTNS/ISMAP/ISFUNC/ISTHR(ANY value)` = MUST return `TRUE` if the runtime type of `value` is respectively `BOOL`, `INT`, `FLT`, `STR`, `TNS`, `MAP`, `FUNC`, or `THR`, and `FALSE` otherwise.
 

src/builtins.c

@@ -8670,16 +8670,14 @@ static Value builtin_permafrozen(Interpreter *interp, Value *args, int argc, Exp
 }
 
 static Value builtin_exist(Interpreter *interp, Value *args, int argc, Expr **arg_nodes, Env *env, int line, int col) {
-    (void)args;
-    (void)interp;
-    (void)line;
-    (void)col;
+    (void)arg_nodes;
 
-    if (argc != 1 || arg_nodes[0]->type != EXPR_IDENT) {
-        return value_bool(false);
+    if (argc != 1) {
+        RUNTIME_ERROR(interp, "EXIST expects 1 argument", line, col);
     }
+    EXPECT_STR(args[0], "EXIST", interp, line, col);
 
-    const char *name = arg_nodes[0]->as.ident;
+    const char *name = args[0].as.s ? args[0].as.s : "";
     return value_bool(env_exists(env, name));
 }
 

src/interpreter.c

@@ -1406,7 +1406,7 @@ Value eval_expr(Interpreter *interp, Expr *expr, Env *env) {
                             deferred_async_arg0 = true;
                             continue;
                         }
-                        if ((strcmp(func_name, "EXIST") == 0 || strcmp(func_name, "ASSIGN") == 0) && i == 0) {
+                        if (strcmp(func_name, "ASSIGN") == 0 && i == 0) {
                             // leave as null placeholder for identifier-like targets
                             continue;
                         }
@@ -1493,7 +1493,7 @@ Value eval_expr(Interpreter *interp, Expr *expr, Env *env) {
 
                 // effective_argc should count the original positional arguments
                 // and extend if any keyword maps beyond them. Do NOT trim placeholder
-                // NULLs for intentionally-unevaluated positional args (e.g. EXIST or ASSIGN).
+                // NULLs for intentionally-unevaluated positional args (e.g. ASSIGN).
                 int effective_argc = pos_argc;
                 if (max_slot > effective_argc) {
                     effective_argc = max_slot;

tests/cases/failing/exist-raw-symbol-argument.pre

@@ -0,0 +1,2 @@
+BOOL x = TRUE
+EXIST(x)

tests/cases/failing/try-catch-err-pseudotype.pre

@@ -1,5 +1,5 @@
 TRY{
     ASSERT(FALSE)
 } CATCH(SYMBOL: err) {
-    ASSERT(EXIST(err))
+    ASSERT(EXIST("err"))
 }

tests/cases/passing/assign.pre

@@ -1,2 +1,2 @@
 ASSIGN(BOOL x, TRUE)
-ASSERT(EXIST(x))
+ASSERT(EXIST("x"))

tests/cases/passing/break-nested.pre

@@ -11,5 +11,5 @@ FOR(i, 0d3){
 }
 ASSERT(EQ(outer, 0d1))
 ASSERT(EQ(inner, 0d1))
-REFUTE(EXIST(i))
-REFUTE(EXIST(j))
+REFUTE(EXIST("i"))
+REFUTE(EXIST("j"))

tests/cases/passing/del-frozen.pre

@@ -8,11 +8,11 @@ TRY{
     frozen_delete_failed = TRUE
 }
 ASSERT(frozen_delete_failed)
-ASSERT(EXIST(frozen_symbol))
+ASSERT(EXIST("frozen_symbol"))
 
 REFUTE(THAW(frozen_symbol))
 REFUTE(DEL("frozen_symbol"))
-REFUTE(EXIST(frozen_symbol))
+REFUTE(EXIST("frozen_symbol"))
 
 BOOL permafrozen_symbol = TRUE
 REFUTE(PERMAFREEZE(permafrozen_symbol))
@@ -24,4 +24,4 @@ TRY{
     permafrozen_delete_failed = TRUE
 }
 ASSERT(permafrozen_delete_failed)
-ASSERT(EXIST(permafrozen_symbol))
+ASSERT(EXIST("permafrozen_symbol"))

tests/cases/passing/del-symbol.pre

@@ -1,7 +1,7 @@
 BOOL symbol = TRUE
-ASSERT(EXIST(symbol))
+ASSERT(EXIST("symbol"))
 REFUTE(DEL("symbol"))
-REFUTE(EXIST(symbol))
+REFUTE(EXIST("symbol"))
 
 BOOL deleted_read_failed = FALSE
 TRY{
@@ -15,4 +15,4 @@ INT count = 0d1
 REFUTE(DEL("count"))
 count = 0d2
 ASSERT(EQ(count, 0d2))
-ASSERT(EXIST(count))
+ASSERT(EXIST("count"))

tests/cases/passing/exist.pre

@@ -1,25 +1,26 @@
 BOOL outer = TRUE
 BOOL declared_only
+STR outer_name = "outer"
 
 FUNC BOOL outer_visible(){
-    RETURN(EXIST(outer))
+    RETURN(EXIST(outer_name))
 }
 
 FUNC BOOL inner_visible(){
     BOOL inner = TRUE
-    RETURN(EXIST(inner))
+    RETURN(EXIST("inner"))
 }
 
 FUNC BOOL missing_visible(){
-    RETURN(EXIST(missing))
+    RETURN(EXIST("missing"))
 }
 
-ASSERT(EXIST(outer))
-REFUTE(EXIST(declared_only))
+ASSERT(EXIST(outer_name))
+REFUTE(EXIST("declared_only"))
 ASSERT(outer_visible())
 ASSERT(inner_visible())
 REFUTE(missing_visible())
 
 DEL("outer")
-REFUTE(EXIST(outer))
+REFUTE(EXIST(outer_name))
 REFUTE(outer_visible())