fix var"true" and var"false" (#34077)

This changes the internal representation of booleans in the front end
to `(true)` and `(false)` to make them easier to distinguish from
identifiers.

Author: JeffBezanson

src/ast.c

@@ -478,13 +478,8 @@ static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, jl_module_t *m
             return (jl_value_t*)jl_box_int32((int32_t)i64);
 #endif
     }
-    if (issymbol(e)) {
-        if (e == jl_ast_ctx(fl_ctx)->true_sym)
-            return jl_true;
-        else if (e == jl_ast_ctx(fl_ctx)->false_sym)
-            return jl_false;
+    if (issymbol(e))
         return (jl_value_t*)scmsym_to_julia(fl_ctx, e);
-    }
     if (fl_isstring(fl_ctx, e))
         return jl_pchar_to_string((char*)cvalue_data(e), cvalue_len(e));
     if (iscons(e) || e == fl_ctx->NIL) {
@@ -501,6 +496,10 @@ static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, jl_module_t *m
                 return jl_box_slotnumber(numval(car_(cdr_(e))));
             else if (hd == jl_ast_ctx(fl_ctx)->null_sym && llength(e) == 1)
                 return jl_nothing;
+            else if (hd == jl_ast_ctx(fl_ctx)->true_sym && llength(e) == 1)
+                return jl_true;
+            else if (hd == jl_ast_ctx(fl_ctx)->false_sym && llength(e) == 1)
+                return jl_false;
         }
         if (issymbol(hd))
             sym = scmsym_to_julia(fl_ctx, hd);
@@ -643,9 +642,9 @@ static int julia_to_scm_noalloc1(fl_context_t *fl_ctx, jl_value_t *v, value_t *r
     else if (jl_is_symbol(v))
         *retval = symbol(fl_ctx, jl_symbol_name((jl_sym_t*)v));
     else if (v == jl_true)
-        *retval = jl_ast_ctx(fl_ctx)->true_sym;
+        *retval = fl_cons(fl_ctx, jl_ast_ctx(fl_ctx)->true_sym, fl_ctx->NIL);
     else if (v == jl_false)
-        *retval = jl_ast_ctx(fl_ctx)->false_sym;
+        *retval = fl_cons(fl_ctx, jl_ast_ctx(fl_ctx)->false_sym, fl_ctx->NIL);
     else if (v == jl_nothing)
         *retval = fl_cons(fl_ctx, jl_ast_ctx(fl_ctx)->null_sym, fl_ctx->NIL);
     else

src/ast.scm

@@ -49,8 +49,6 @@
 (define (deparse e (ilvl 0))
   (cond ((or (symbol? e) (number? e)) (string e))
         ((string? e) (print-to-string e))
-        ((eq? e #t) "true")
-        ((eq? e #f) "false")
         ((eq? (typeof e) 'julia_value)
          (let ((s (string e)))
            (if (string.find s "#<julia: ")
@@ -75,6 +73,9 @@
              (string (deparse (cadr e)) " " (car e) " " (deparse (caddr e)))))
         (else
          (case (car e)
+           ((null)  "nothing")
+           ((true)  "true")
+           ((false) "false")
            ;; calls and operators
            ((call)
             (cond ((and (eq? (cadr e) ':) (or (length= e 4) (length= e 5)))
@@ -86,7 +87,7 @@
                    (string #\( (deparse (caddr e)) " " (cadr e) " " (deparse (cadddr e)) #\) ))
                   (else
                    (deparse-prefix-call (cadr e) (cddr e) #\( #\)))))
-           (($ &)          (if (and (pair? (cadr e)) (not (eq? (caadr e) 'outerref)))
+           (($ &)          (if (and (pair? (cadr e)) (not (memq (caadr e) '(outerref null true false))))
                                (string (car e) "(" (deparse (cadr e)) ")")
                                (string (car e) (deparse (cadr e)))))
            ((|::|)         (if (length= e 2)
@@ -170,7 +171,7 @@
                     (indented-block (cdr (cadr e)) ilvl)
                     (if (and (pair? (cadddr e)) (eq? (car (cadddr e)) 'block))
                         (string (string.rep "    " ilvl) "catch"
-                                (if (eq? (caddr e) 'false)
+                                (if (equal? (caddr e) '(false))
                                     ""
                                     (string " " (caddr e)))
                                 "\n"
@@ -192,15 +193,15 @@
 				     (deparse-arglist args))
 			     (cdr body) ilvl)))
            ((struct)
-            (string (if (eq? (cadr e) 'true) "mutable " "")
+            (string (if (equal? (cadr e) '(true)) "mutable " "")
                     "struct "
                     (deparse-block (deparse (caddr e)) (cdr (cadddr e)) ilvl)))
            ((abstract)
             (string "abstract type " (deparse (cadr e)) " end"))
            ((primitive)
             (string "primitive type " (deparse (cadr e)) " " (deparse (caddr e)) " end"))
            ((module)
-            (string (if (eq? (cadr e) 'true) "module " "baremodule ")
+            (string (if (equal? (cadr e) '(true)) "module " "baremodule ")
                     (caddr e) "\n"
                     (string.join (map deparse (cdr (cadddr e))) "\n") "\n"
                     "end"))
@@ -289,7 +290,7 @@
   (error (string #\" (deparse v) #\" " is not a valid function argument name")))
 
 (define (valid-name? s)
-  (not (memq s '(true false ccall cglobal))))
+  (not (memq s '(ccall cglobal))))
 
 (define (arg-name v)
   (cond ((and (symbol? v) (valid-name? v))
@@ -351,17 +352,16 @@
   (and (pair? e) (eq? (car e) 'globalref)))
 
 (define (symbol-like? e)
-  (or (and (symbol? e) (not (eq? e 'true)) (not (eq? e 'false)))
-      (ssavalue? e)))
+  (or (symbol? e) (ssavalue? e)))
 
 (define (simple-atom? x)
-  (or (number? x) (string? x) (char? x) (eq? x 'true) (eq? x 'false)
-      (and (pair? x) (memq (car x) '(ssavalue null)))
+  (or (number? x) (string? x) (char? x)
+      (and (pair? x) (memq (car x) '(ssavalue null true false)))
       (eq? (typeof x) 'julia_value)))
 
 ;; identify some expressions that are safe to repeat
 (define (effect-free? e)
-  (or (not (pair? e)) (ssavalue? e) (sym-dot? e) (quoted? e) (equal? e '(null))))
+  (or (not (pair? e)) (ssavalue? e) (sym-dot? e) (quoted? e) (memq (car e) '(null true false))))
 
 ;; get the variable name part of a declaration, x::int => x
 (define (decl-var v)

src/jlfrontend.scm

@@ -111,8 +111,7 @@
   (and (pair? e)
        (or (memq (car e) '(toplevel line module import using export
                                     error incomplete))
-           (and (memq (car e) '(global const)) (every symbol? (cdr e))
-                (every (lambda (x) (not (memq x '(true false)))) (cdr e))))))
+           (and (memq (car e) '(global const)) (every symbol? (cdr e))))))
 
 (define *in-expand* #f)
 

src/julia-parser.scm

@@ -1306,7 +1306,7 @@
   (if (reserved-word? (peek-token s))
       (error (string "invalid type name \"" (take-token s) "\"")))
   (let ((sig (parse-subtype-spec s)))
-    (begin0 (list 'struct (if mut? 'true 'false) sig (parse-block s))
+    (begin0 (list 'struct (if mut? '(true) '(false)) sig (parse-block s))
             (expect-end s word))))
 
 ;; consume any number of line endings from a token stream
@@ -1472,8 +1472,8 @@
             (take-token s)
             (cond
              ((eq? nxt 'end)
-              (list* 'try try-block (or catchv 'false)
-                     (or catchb (if finalb 'false (error "try without catch or finally")))
+              (list* 'try try-block (or catchv '(false))
+                     (or catchb (if finalb '(false) (error "try without catch or finally")))
                      (if finalb (list finalb) '())))
              ((and (eq? nxt 'catch)
                    (not catchb))
@@ -1487,8 +1487,7 @@
                           finalb)
                     (let* ((loc (line-number-node s))
                            (var (if nl #f (parse-eq* s)))
-                           (var? (and (not nl) (or (and (symbol? var) (not (eq? var 'false))
-                                                        (not (eq? var 'true)))
+                           (var? (and (not nl) (or (symbol? var)
                                                    (and (length= var 2) (eq? (car var) '$))
                                                    (error (string "invalid syntax \"catch " (deparse var) "\"")))))
                            (catch-block (if (eq? (require-token s) 'finally)
@@ -1502,7 +1501,7 @@
                                                    (linenum? (cadr catch-block)))
                                               '()
                                               (cdr catch-block))))
-                            (if var? var 'false)
+                            (if var? var '(false))
                             finalb)))))
              ((and (eq? nxt 'finally)
                    (not finalb))
@@ -1533,7 +1532,7 @@
           (if (reserved-word? name)
               (error (string "invalid module name \"" name "\"")))
           (expect-end s word)
-          (list 'module (if (eq? word 'module) 'true 'false) name
+          (list 'module (if (eq? word 'module) '(true) '(false)) name
                 `(block ,loc ,@(cdr body)))))
        ((export)
         (let ((es (map macrocall-to-atsym
@@ -2290,22 +2289,23 @@
                       (if (closing-token? t)
                           (error (string "unexpected \"" (take-token s) "\"")))))
            (take-token s)
-           (if (and (eq? t 'var)
-                    (if (or (ts:pbtok s) (ts:last-tok s))
-                        (and (eqv? (peek-token s) #\") (not (ts:space? s)))
-                        ;; Hack: avoid peek-token if possible to preserve
-                        ;; (io.pos (ts:port s)) for non-greedy Meta.parse
-                        (eqv? (peek-char (ts:port s)) #\")))
-             (begin
-               ;; var"funky identifier" syntax
-               (peek-token s)
-               (take-token s) ;; leading "
-               (let ((str (parse-raw-literal s #\"))
-                     (nxt (peek-token s)))
-                 (if (and (symbol? nxt) (not (operator? nxt)) (not (ts:space? s)))
-                     (error (string "suffix not allowed after `var\"" str "\"`")))
-                 (symbol str)))
-             t))
+           (cond ((and (eq? t 'var)
+                       (if (or (ts:pbtok s) (ts:last-tok s))
+                           (and (eqv? (peek-token s) #\") (not (ts:space? s)))
+                           ;; Hack: avoid peek-token if possible to preserve
+                           ;; (io.pos (ts:port s)) for non-greedy Meta.parse
+                           (eqv? (peek-char (ts:port s)) #\")))
+                  ;; var"funky identifier" syntax
+                  (peek-token s)
+                  (take-token s) ;; leading "
+                  (let ((str (parse-raw-literal s #\"))
+                        (nxt (peek-token s)))
+                    (if (and (symbol? nxt) (not (operator? nxt)) (not (ts:space? s)))
+                        (error (string "suffix not allowed after `var\"" str "\"`")))
+                    (symbol str)))
+                 ((eq? t 'true)  '(true))
+                 ((eq? t 'false) '(false))
+                 (else t)))
 
           ;; parens or tuple
           ((eqv? t #\( )