From 6c017c2cf807643535a2a7dff5c64d9b20a0dd89 Mon Sep 17 00:00:00 2001 From: Joseph Ferano Date: Sun, 20 Sep 2026 18:02:59 +0700 Subject: [PATCH] Six dogfooding items: empty bodies, comment, inc/dec, () bodies, type limits, {.field} --- lib/parse.ml | 42 ++++++-- lib/prelude.ml | 168 +++++++++++++++++++++++++++++- test/programs/destructure.flan | 10 ++ test/programs/limits.flan | 121 +++++++++++++++++++++ test/programs/prelude-macros.flan | 103 ++++++++++++++++++ test/test_acceptance.ml | 64 +++++++++++- vendor/raylib/modes.flan | 32 +++++- 7 files changed, 526 insertions(+), 14 deletions(-) create mode 100644 test/programs/limits.flan create mode 100644 test/programs/prelude-macros.flan diff --git a/lib/parse.ml b/lib/parse.ml index 6a5ac37..563f2aa 100644 --- a/lib/parse.ml +++ b/lib/parse.ml @@ -348,9 +348,15 @@ and form f mk (head : Form.t) (args : Form.t list) : Ast.expr = | _ -> fail f "if is (if test then) or (if test then else)") (* Sugar, desugared here: special forms until macros land at milestone 5. *) + (* An empty body is allowed, and becomes the same [Ast.Do []] that [(do)] + already means. There was never a reason for the restriction: [(when test)] + is a guard whose consequent has not been written yet, which is a state a + program passes through while it is being written, and refusing it buys + nothing. A [(when)] with no test at all is still refused, because there is + no expression to test. *) | Sym "when" -> (match args with - | c :: body when body <> [] -> + | c :: body -> mk (Ast.If (expr c, { Ast.e = Ast.Do (body_of body); loc = f.loc }, None)) | _ -> fail f "when is (when test body ...)") @@ -755,11 +761,27 @@ and destructure (p : Form.t) (v : Ast.expr) : Ast.binding list = {:keys [x y]} over a struct or [a b] over a fixed array" (Form.to_string p) -(* {:keys [x y]} and {inner .field}, over a struct. Clojure's map destructuring - with Flan's structs standing in for its maps: [:keys] is the common case and - the pair form is what nests, since a [:keys] entry is a name and never a - pattern. Everything else Clojure puts in this position — [:as], [:or], - [:strs], [:syms] — is refused by name where it is written. +(* {:keys [x y]}, {.x .y} and {inner .field}, over a struct. Clojure's map + destructuring with Flan's structs standing in for its maps: [:keys] is the + common case and the pair form is what nests, since a [:keys] entry is a name + and never a pattern. Everything else Clojure puts in this position — [:as], + [:or], [:strs], [:syms] — is refused by name where it is written. + + [{.x .y}] is [:keys]'s other spelling and the shortest one: a lone [.field] + with no pattern before it binds a local of the field's own name. It is what + [:keys] would have been if the language had only ever had structs — a + struct's fields are typed and known, so naming one is naming the binding — + and it puts the field syntax in the place the rest of the language spells a + field. [:keys] stays, because a dyn map's keys are not field names and that + is the form they will keep. + + This arm comes before the pair arm and has to: a lone [.x] is a [Sym], and + [destructure] takes any [Sym] as a name, so before this existed [{.x .y}] + parsed as the pair "bind a local called [.x] to field [y]" and the program + failed later with "unknown name x" — a mis-parse rather than a refusal. An + odd number of them hit the [has no .field] arm instead. So the dot in head + position did have a meaning here, and this replaces it with the one that was + wanted. [:keys] keeps its colon while [.field] takes the dot, and the split is the point rather than an inconsistency: [.field] names a field of the struct, @@ -770,8 +792,16 @@ and destructure (p : Form.t) (v : Ast.expr) : Ast.binding list = and dmap (p : Form.t) (t : Ast.expr) (items : Form.t list) : Ast.binding list = let ex loc e : Ast.expr = { Ast.e; loc } in let field loc name = ex loc (Ast.Field (t, name)) in + let dotted s = String.length s > 1 && s.[0] = '.' in let rec go = function | [] -> [] + (* The shorthand. Checked first, so a [.field] in head position is never + read as a name to bind. *) + | ({ v = Sym s; _ } as fform) :: rest when dotted s -> + let name = String.sub s 1 (String.length s - 1) in + { Ast.bname = name; bty = None; bval = field fform.loc name; + bloc = fform.loc } + :: go rest | { v = Kw "keys"; _ } :: names :: rest -> let ns = match names.v with diff --git a/lib/prelude.ml b/lib/prelude.ml index b015fd9..c9610c9 100644 --- a/lib/prelude.ml +++ b/lib/prelude.ml @@ -553,6 +553,80 @@ let source = {flan| (set i (+ i 1))) (if neg (Some (- 0 n)) (Some n)))) +;; ── The limits of each numeric type ─────────────────────────────────── +;; +;; What C spells INT_MAX and FLT_MAX, and what nothing here could reach for: +;; cimport pulls in declared functions, structs and typedefs, never a #define, +;; so limits.h and float.h have no way in. These are written out instead, once, +;; where every program already sees them. +;; +;; Kebab-case and the type's own name, like ns-per-second above: i32-max, not +;; I32_MAX and not INT_MAX. The type prefix is the type as the language spells +;; it, so the constant for a u8 is u8-max and there is nothing to translate. +;; +;; Each carries its type, which is the point of them — i32-max is an i32 and +;; putting it where a u8 is wanted is a type error rather than a silent 255. +;; That also means the pair for a type is the pair the *language* has, so +;; u8-min is here beside u16-min and u32-min and u64-min, all of them zero: a +;; family with a hole in it is worse than four lines that say nothing +;; surprising, and code generated over a list of type names needs the hole +;; filled. +;; +;; u64-max is written in hex and it has to be. The reader parses a decimal +;; integer into an i64, and 18446744073709551615 does not fit one; the hex +;; spelling is read as the 64-bit pattern it names, which is what a u64 +;; literal is here (see [Check.in_range], which accepts any pattern at 64 bits +;; unsigned for exactly this reason). i64-min's decimal spelling *does* fit, +;; since it is i64's own least value, so it is written the ordinary way. +(defconst i8-max i8 127) +(defconst i8-min i8 -128) +(defconst i16-max i16 32767) +(defconst i16-min i16 -32768) +(defconst i32-max i32 2147483647) +(defconst i32-min i32 -2147483648) +(defconst i64-max i64 9223372036854775807) +(defconst i64-min i64 -9223372036854775808) + +(defconst u8-max u8 255) +(defconst u8-min u8 0) +(defconst u16-max u16 65535) +(defconst u16-min u16 0) +(defconst u32-max u32 4294967295) +(defconst u32-min u32 0) +(defconst u64-max u64 0xFFFFFFFFFFFFFFFF) +(defconst u64-min u64 0) + +;; The floats are three questions and not two, which is why there is no +;; f32-min here to sit beside f32-max. +;; +;; A float's least value is just the negation of its greatest — (- 0.0 f32-max) +;; — so a constant for it would say nothing the language cannot. What a caller +;; actually reaches for under the name "min" is the smallest positive one, and +;; that is a different number entirely. Naming it f32-min would make the two +;; readings collide at the worst possible place, so the name says which it is: +;; f32-min-positive, the smallest *normal* positive value, as Rust's +;; MIN_POSITIVE does. Below it the subnormals run further down still, trading +;; mantissa bits for exponent range; nothing here names one, because a program +;; that wants the last subnormal wants to say so. +;; +;; The epsilons are the gap from 1.0 to the next representable value above it — +;; 2^-23 and 2^-52, the mantissa widths — and not "the smallest number you can +;; add to anything". That distinction is the whole reason a comparison written +;; (< (abs (- a b)) f64-epsilon) is wrong for any a and b of interesting size, +;; and the reason this is named epsilon and not tolerance. +;; +;; Every decimal below is the shortest one that round-trips to the exact value +;; intended, and each is pinned against an independent derivation in +;; test/programs/limits.flan rather than trusted. There is no infinity or NaN +;; constant, and there cannot be one written down: the reader has no literal +;; for either. (/ 1.0 0.0) is the only way to reach an infinity today. +(defconst f32-max f32 3.4028234663852886e38) +(defconst f64-max f64 1.7976931348623157e308) +(defconst f32-min-positive f32 1.1754943508222875e-38) +(defconst f64-min-positive f64 2.2250738585072014e-308) +(defconst f32-epsilon f32 1.1920928955078125e-07) +(defconst f64-epsilon f64 2.220446049250313e-16) + ;; ── Numbers ─────────────────────────────────────────────────────────── ;; ;; Only the ones that encode a decision. abs is (max x (- 0 x)); a wrapper over @@ -1960,11 +2034,91 @@ let source = {flan| ;; nothing defines, and the report is "unknown name unless-takes-a-test-and-a- ;; body" at the call site, which is the right place and the wrong sentence. ;; That is the next thing a macro needs and it is written down in NEXT.md. +;; +;; An empty body is allowed, and expands to the (do) it always would have: +;; (unless test) is a guard whose body has not been written yet, which is a +;; state a program passes through on the way to being finished, and refusing it +;; bought nothing. `when` in lib/parse.ml is the same change; the two are +;; halves of one form and only a restriction they both carried would be worth +;; keeping. A test is still required, because there is nothing to negate +;; without one. (defmacro unless [args] - (if (< (len args) 2) - `(unless-takes-a-test-and-a-body) + (if (< (len args) 1) + `(unless-takes-a-test) `(if (not ~(at args 0)) (do ~@(form-rest args 1))))) +;; ── comment ─────────────────────────────────────────────────────────── +;; +;; (comment (whatever you like)) is nothing at all, and the "whatever you like" +;; is the whole feature. A macro's arguments arrive as raw Form and are never +;; checked as expressions, so what is inside can name functions that do not +;; exist, call them at the wrong arity, or add a string to a number: none of it +;; is ever looked at, because this answers (do) without reading a single +;; argument. That is Clojure's (comment ...) exactly, and it is what ;; cannot +;; do — a commented-out block stops being a form, so an editor can no longer +;; move over it, indent it or send it to the REPL, and a discarded one still +;; can. +;; +;; The one thing it does require is that the contents READ: balanced +;; delimiters and legal tokens, since the reader runs before any macro does. +;; An unterminated string inside a (comment ...) is still an unterminated +;; string. +;; +;; #_ is the other spelling and they are not rivals: #_ discards the one form +;; after it and is the reader's, so it works in any position including inside +;; another form's arguments; this is a form of its own and takes any number, +;; which is what a block of parked code wants. Built in rather than left to +;; every project, because a name this standard should mean the same thing in +;; all of them. +(defmacro comment [args] + `(do)) + +;; ── inc/dec and ++/-- ───────────────────────────────────────────────── +;; +;; Two pairs, and the split between them is the whole design. inc and dec +;; answer a number and change nothing; ++ and -- change a place and answer +;; whatever `set` answers. The spelling says which: a word for the pure one, a +;; punctuation pair borrowed from C for the one with the effect, so +;; (inc i) in an argument and (++ i) as a statement never get confused for one +;; another the way C's i++ and i+1 do. +;; +;; Generic for free, all four of them, because + and - already are: (inc x) is +;; (+ x 1) with the literal taking whichever numeric type x has — i8 through +;; i64, u8 through u64, f32, f64, and a dyn — and none of that is this macro's +;; business. There is no per-type family here and there is no `where` clause, +;; because a macro does not have a type at all; the expansion is checked at the +;; call site as if it had been written there. +;; +;; **++ and -- read the place twice, and that is an accepted cost.** The +;; expansion is (set PLACE (+ PLACE 1)), so PLACE is evaluated once to read +;; and once to write. For a variable, a field or a deref that is free and +;; means nothing. For (at arr (next-index)) — an index with a side effect — +;; it means next-index runs twice and the read and the write land on different +;; elements. That is not a bug to be fixed here: macros are non-hygienic by +;; decision (plan.org, open decision 2), a macro cannot bind a temporary for +;; the *place* without a reference type it does not have, and +;; rl/with-drawing and rl/with-mode-2d already take the same trade on their +;; arguments. Write the index out first if it does anything. +(defmacro inc [args] + (if (!= (len args) 1) + `(inc-takes-one-number) + `(+ ~(at args 0) 1))) + +(defmacro dec [args] + (if (!= (len args) 1) + `(dec-takes-one-number) + `(- ~(at args 0) 1))) + +(defmacro ++ [args] + (if (!= (len args) 1) + `(++-takes-one-place) + `(set ~(at args 0) (+ ~(at args 0) 1)))) + +(defmacro -- [args] + (if (!= (len args) 1) + `(---takes-one-place) + `(set ~(at args 0) (- ~(at args 0) 1)))) + ;; ── into: a fused transformation, and not a transducer ──────────────── ;; ;; (into xs (vec-new i32) (map double) (filter even?)) @@ -2049,6 +2203,16 @@ let source = {flan| (Form.Sym s) (bytes=? (bytes s) (bytes name)) _ false)) +;; Whether a form is the empty list, (). [form-items] cannot answer this: it +;; returns the empty slice for a non-list too, so "no items" and "not a list" +;; arrive the same. A macro that has to tell `()` from a name needs the +;; difference — see vendor/raylib/modes.flan, where a lone () argument is a +;; body that was not written rather than a body of one form. +(defn form-empty-list? [f Form] bool + (match f + (Form.List xs) (= (len xs) 0) + _ false)) + (defn form-is-sym? [f Form] bool (match f (Form.Sym s) true diff --git a/test/programs/destructure.flan b/test/programs/destructure.flan index 5ebf6be..ed6bc90 100644 --- a/test/programs/destructure.flan +++ b/test/programs/destructure.flan @@ -40,6 +40,16 @@ (let [{a .x b .y} (Point {.x 10 .y 20})] (show2 "pairs" a b)) + ;; The shorthand: a lone .field with no name before it binds a local of the + ;; field's own name, which is what :keys does and in the spelling the rest of + ;; the language uses for a field. It mixes with the pair form in one brace, + ;; because the two are read one item at a time and a dot in head position is + ;; the only thing that tells them apart. + (let [{.x .y} (Point {.x 30 .y 40})] + (show2 "shorthand" x y)) + (let [{.x b .y} (Point {.x 50 .y 60})] + (show2 "shorthand-mixed" x b)) + (let [l (Line {.a (Point {.x 5 .y 6}) .b (Point {.x 7 .y 8})})] (let [{{:keys [x y]} .b} l] (show2 "nested" x y)) diff --git a/test/programs/limits.flan b/test/programs/limits.flan new file mode 100644 index 0000000..6c43082 --- /dev/null +++ b/test/programs/limits.flan @@ -0,0 +1,121 @@ +;;;; The prelude's type limits, checked against something other than themselves. +;;;; +;;;; A wrong constant here would compile. That is the whole reason this program +;;;; exists: i32-max off by one, or f64-max one ulp low, is a number the +;;;; compiler has no opinion about, and it would sit in the prelude being +;;;; subtly wrong in every program that read it. So nothing below asserts a +;;;; constant against the way it is spelled in the prelude. +;;;; +;;;; The integers are checked by printing them. The expected output beside this +;;;; program in test_acceptance is the decimal spelling of each limit, written +;;;; out independently, and an integer's decimal rendering is exact — so the +;;;; comparison is the whole value and not an approximation of it. u64-max is +;;;; the one that matters most: it is written in hex in the prelude, because +;;;; the reader cannot take its decimal, and this is where that hex is read +;;;; back as the number it is supposed to name. +;;;; +;;;; The floats cannot be checked that way, because printing one is snprintf +;;;; "%g" and that is six significant digits — 3.40282e+38 is equally true of +;;;; f32-max and of a dozen values around it. So each is *derived* here by +;;;; exact power-of-two arithmetic and compared for equality. Every step of +;;;; that derivation is exact in IEEE-754: doubling and halving a float only +;;;; moves the exponent, and the one multiplication that is not a power of two +;;;; has both operands representable and a representable product. The +;;;; derivations are therefore a second, independent construction of the same +;;;; bit pattern, which is what a pin needs to be. + +;; 2^n, built by repeated doubling from 1.0 and reciprocated for a negative n. +;; Exact for every n this program asks for: the largest is 2^1023, which is +;; half of f64-max and so is nowhere near overflowing, and the smallest is +;; 2^-1022, whose reciprocal partner 2^1022 is a normal value — so no step +;; passes through a subnormal, where the halving would start losing bits. +(defn p2-f64 [n i32] f64 + (let [m (if (< n 0) (- 0 n) n) + x 1.0] + (dotimes [i m] + (set x (* x 2.0))) + (if (< n 0) (/ 1.0 x) x))) + +;; The same, at f32's width and with f32's exponent range. 2^127 is the +;; largest normal power of two an f32 holds and 2^-126 the smallest, and both +;; are exactly the ends this file asks for. +(defn p2-f32 [n i32] f32 + (let [m (if (< n 0) (- 0 n) n) + x (f32 1.0)] + (dotimes [i m] + (set x (* x (f32 2.0)))) + (if (< n 0) (/ (f32 1.0) x) x))) + +;; An infinity is a value that equals its own double and is not zero — the +;; same test format-f64 in the prelude uses, and the only one available with +;; no infinity literal to compare against. +(defn inf-f64? [x f64] bool + (and (= x (* x 2.0)) (!= x 0.0))) + +(defn inf-f32? [x f32] bool + (and (= x (* x (f32 2.0))) (!= x (f32 0.0)))) + +(defn say [name string ok bool] () + (print name) + (print " ") + (println (if ok "ok" "WRONG"))) + +(defn main [] i32 + ;; The integers, each printed as the exact decimal the expected output pins. + (println i8-max) + (println i8-min) + (println i16-max) + (println i16-min) + (println i32-max) + (println i32-min) + (println i64-max) + (println i64-min) + (println u8-max) + (println u8-min) + (println u16-max) + (println u16-min) + (println u32-max) + (println u32-min) + (println u64-max) + (println u64-min) + + ;; The floats, each against its derivation. + ;; + ;; An epsilon is the gap from 1.0 to the next value above it, which is + ;; 2^-(mantissa bits): 23 for an f32, 52 for an f64. Derived that way here, + ;; and then confirmed by the property the name actually promises — adding it + ;; to 1.0 moves, adding half of it does not. + (say "f32-epsilon" (= f32-epsilon (p2-f32 -23))) + (say "f64-epsilon" (= f64-epsilon (p2-f64 -52))) + (say "f32-epsilon is the step above 1.0" + (and (!= (+ (f32 1.0) f32-epsilon) (f32 1.0)) + (= (+ (f32 1.0) (/ f32-epsilon (f32 2.0))) (f32 1.0)))) + (say "f64-epsilon is the step above 1.0" + (and (!= (+ 1.0 f64-epsilon) 1.0) + (= (+ 1.0 (/ f64-epsilon 2.0)) 1.0))) + + ;; The smallest positive *normal* value is 2^(1-bias): 2^-126 and 2^-1022. + ;; Halving one leaves the normals, so the value below it is not simply half + ;; — that is the property that says this is the boundary and not some value + ;; near it. + (say "f32-min-positive" (= f32-min-positive (p2-f32 -126))) + (say "f64-min-positive" (= f64-min-positive (p2-f64 -1022))) + + ;; The greatest finite value is (2 - 2^-mantissa) * 2^maxexp. Both factors + ;; are exactly representable and so is the product, which is why this + ;; derivation is an equality and not a near-miss. Doubling it overflows to + ;; an infinity, which is the other end of the same claim: there is nothing + ;; finite above it. + (say "f32-max" (= f32-max (* (p2-f32 127) (- (f32 2.0) (p2-f32 -23))))) + (say "f64-max" (= f64-max (* (p2-f64 1023) (- 2.0 (p2-f64 -52))))) + (say "f32-max is the last finite f32" (inf-f32? (* f32-max (f32 2.0)))) + (say "f64-max is the last finite f64" (inf-f64? (* f64-max 2.0))) + + ;; And the two the language does not need a constant for, said once so that + ;; the absence is recorded rather than merely unmentioned: a float's least + ;; value is the negation of its greatest, and there is nothing to derive. + (say "f32's least value negates its greatest" + (< (- (f32 0.0) f32-max) (- (f32 0.0) f32-min-positive))) + (say "f64's least value negates its greatest" + (< (- 0.0 f64-max) (- 0.0 f64-min-positive))) + 0) diff --git a/test/programs/prelude-macros.flan b/test/programs/prelude-macros.flan new file mode 100644 index 0000000..d4ec1dc --- /dev/null +++ b/test/programs/prelude-macros.flan @@ -0,0 +1,103 @@ +;;;; comment, inc/dec, ++/--, and an empty body — the prelude's small macros, +;;;; asserted through a compiler that has to run them. +;;;; +;;;; These cannot be asserted in test_flan the way a special form can: a macro +;;;; is compiled into a shared object and dlopened into the compiler before +;;;; the first line below is parsed, so the only honest test of one is a +;;;; program that was built. macro-unless.flan beside this file is the same +;;;; argument for the same reason. + +(defstruct Counter [hits i32 misses i32]) + +(defvar dyn-count dyn 5) + +(defn show [label string n i32] () + (print label) + (print " ") + (println n)) + +;; (comment ...) never reads its arguments, so nothing inside one has to be a +;; program. Everything in this function's comment would be a refusal written +;; anywhere else: a name nothing defines, a call at an arity it does not have, +;; a string added to a number, a field of a struct that has no such field. +;; The one rule it does obey is the reader's — delimiters balance and every +;; token is legal — because reading happens before any macro runs. +(defn commented [] i32 + (comment + (no-such-function 1 2 3) + (show "too" "few") + (+ 1 "two") + (.nonexistent (Counter {})) + (defn this is not even a definition)) + 7) + +(defn main [] i32 + (println (commented)) + + ;; inc and dec answer a number and change nothing. + (let [n 10] + (show "inc" (inc n)) + (show "dec" (dec n)) + (show "n unchanged" n)) + + ;; Generic for free at every numeric type, because + and - already are. + ;; Nothing below names a type twice and there is no per-type family. + (let [a (i8 1) + b (i16 1) + c 1 + d (i64 1) + e (u8 1) + f (u16 1) + g (u32 1) + h (u64 1)] + (print (inc a)) (print " ") + (print (inc b)) (print " ") + (print (inc c)) (print " ") + (print (inc d)) (print " ") + (print (inc e)) (print " ") + (print (inc f)) (print " ") + (print (inc g)) (print " ") + (println (inc h))) + (let [x (f32 1.5) + y 1.5] + (print (inc x)) (print " ") + (println (dec y))) + (println (inc dyn-count)) + + ;; ++ and -- change a place. Every place `set` takes is one: a local, a + ;; field, an element, a deref. + (let [n 0] + (++ n) + (++ n) + (-- n) + (show "local" n)) + + (let [c (Counter {.hits 0 .misses 9})] + (++ (.hits c)) + (++ (.hits c)) + (-- (.misses c)) + (show "field hits" (.hits c)) + (show "field misses" (.misses c))) + + (let [xs [10 20 30]] + (++ (at xs 1)) + (-- (at xs 2)) + (show "element 1" (at xs 1)) + (show "element 2" (at xs 2))) + + (let [n 100 + p (addr n)] + (++ (deref p)) + (show "through a pointer" n)) + + ;; A body that was not written. (when test) and (unless test) are the guard + ;; a program passes through while it is being written, and both expand to + ;; the (do) they always would have — no branch taken, nothing printed, and + ;; the form's value is () either way. + (let [n 0] + (when (= n 0)) + (unless (= n 0)) + (when (= n 0) (++ n)) + (unless (= n 1) (++ n)) + (show "after empty and written bodies" n)) + 0) diff --git a/test/test_acceptance.ml b/test/test_acceptance.ml index bcc7366..1f4c0bb 100644 --- a/test/test_acceptance.ml +++ b/test/test_acceptance.ml @@ -3426,6 +3426,29 @@ level "1" outputs ~opt:"-O0" "unless, now a prelude macro, -O0" "programs/macro-unless.flan" unless_out; + (* The rest of the prelude's macros, and for the same reason: a macro is + compiled into a shared object and dlopened into the compiler before the + program that calls it is parsed, so the only honest assertion about one + is a program that was built. + + The generic row -- eight integer widths, two float widths and a dyn, + all printing 2 or the obvious successor -- is the claim that inc and + dec needed no type machinery of their own: + already works at every one + of those, and a macro has no type to get in the way. A per-type family + would have had to be written and this row would look the same, which is + why it prints the answers rather than merely compiling. *) + let prelude_macros_out = + "7\ninc 11\ndec 9\nn unchanged 10\n\ + 2 2 2 2 2 2 2 2\n2.5 0.5\n6\n\ + local 1\nfield hits 2\nfield misses 8\n\ + element 1 21\nelement 2 29\nthrough a pointer 101\n\ + after empty and written bodies 1\n" + in + outputs "comment, inc/dec, ++/-- and an empty body" + "programs/prelude-macros.flan" prelude_macros_out; + outputs ~opt:"-O0" "comment, inc/dec, ++/-- and an empty body, -O0" + "programs/prelude-macros.flan" prelude_macros_out; + (* An error on code a macro produced says which macro, and it has to be asserted through a real expansion: the tag is put on by [Macro] and defaulted into the diagnostic by [Loc], and a unit test on either half @@ -4240,6 +4263,44 @@ level "1" incr failures; Printf.printf "FAIL %s\n refused: %S\n" name m); + (* ── The prelude's type limits ──────────────────────────────── *) + + (* A wrong constant compiles, which is the only reason this row is worth + its seconds: nothing in the compiler has an opinion about whether + i32-max is 2147483647 or one less, and a prelude constant that is + subtly wrong is wrong in every program that reads it. + + The expected text below is written out from the definitions of the + types and not copied from the prelude, so the two spellings of each + integer limit have to agree. The floats cannot be pinned this way — + printing one is "%g", six digits, true of a whole neighbourhood of + values — so limits.flan derives each by exact power-of-two arithmetic + and prints whether the derivation matched; a WRONG in that half fails + this row on the text. + + --x86 as well, and that is not ceremony: a limit is a constant the + backend has to materialise, and the two backends build an f64 bit + pattern and a full-width u64 immediate by entirely different routes. + An x86 lowering that truncated one would print a number this row + would catch and nothing else in the suite would. *) + let limits_out = + "127\n-128\n32767\n-32768\n2147483647\n-2147483648\n\ + 9223372036854775807\n-9223372036854775808\n\ + 255\n0\n65535\n0\n4294967295\n0\n18446744073709551615\n0\n\ + f32-epsilon ok\nf64-epsilon ok\n\ + f32-epsilon is the step above 1.0 ok\n\ + f64-epsilon is the step above 1.0 ok\n\ + f32-min-positive ok\nf64-min-positive ok\n\ + f32-max ok\nf64-max ok\n\ + f32-max is the last finite f32 ok\n\ + f64-max is the last finite f64 ok\n\ + f32's least value negates its greatest ok\n\ + f64's least value negates its greatest ok\n" + in + outputs "type limits" "programs/limits.flan" limits_out; + outputs ~opt:"-O0" "type limits, -O0" "programs/limits.flan" limits_out; + outputs ~x86:true "type limits, --x86" "programs/limits.flan" limits_out; + let signed_out = "-4\n-1\nbig is not small\nbig is large\n1\n" in outputs "signedness" "programs/signedness.flan" signed_out; outputs ~opt:"-O0" "signedness, -O0" "programs/signedness.flan" signed_out; @@ -4256,7 +4317,8 @@ level "1" tail slice is an address into a local array, and mem2reg launders a sloppy one. *) let destructure_out = - "keys 1 2\npairs 10 20\nnested 7 8\nshadow 5 6\nsequential 100 200\n\ + "keys 1 2\npairs 10 20\nshorthand 30 40\nshorthand-mixed 50 60\n\ + nested 7 8\nshadow 5 6\nsequential 100 200\n\ array 11 22 33\nrest 1 4 2 5\nempty-tail 17 0\nnested-in-array 1 4\n\ struct-tail 1 2 4 5\ncalls 2 14\n" in diff --git a/vendor/raylib/modes.flan b/vendor/raylib/modes.flan index 7910e7f..86ebc60 100644 --- a/vendor/raylib/modes.flan +++ b/vendor/raylib/modes.flan @@ -74,10 +74,28 @@ ;;;; Each macro answers the value of its `End*` call, which is (). A pair was ;;;; never an expression worth reading anyway. +;; Each guard below asks the same question twice over, and the second half is +;; the one worth explaining. A body that was not written can arrive two ways: +;; as no argument at all — (with-drawing) — and as a single bare () — +;; (with-drawing ()). The second used to slip past, because one argument is one +;; argument however empty it is: the () was spliced into the expansion +;; verbatim, and the report came out of the middle of the expanded (do) saying +;; that () is not an expression, several forms away from the line anyone wrote. +;; () has no value-position meaning in the language at all, so a lone one here +;; is never a body and can be answered with the same message the missing-body +;; case gets. (do) is what to write for a body that really is meant to be +;; empty, and it is an ordinary expression that needs none of this. +;; +;; Only a *lone* () is caught, and only where the body goes. () anywhere else — +;; as a camera, as a render target — is left to fail on its own, because +;; nothing here could say anything truer about it than the compiler already +;; does. + ;; The frame. Everything drawn lands on the back buffer; end-drawing swaps it ;; and waits out the frame time set by set-target-fps. (defmacro with-drawing [args] - (if (< (len args) 1) + (if (or (< (len args) 1) + (and (= (len args) 1) (form-empty-list? (at args 0)))) `(with-drawing-takes-a-body) `(do (begin-drawing) ~@args @@ -87,7 +105,8 @@ ;; always was. Remember that a fresh (Camera2D {}) has zoom 0.0 and is not ;; usable as an identity — raylib.flan says so beside the struct. (defmacro with-mode-2d [args] - (if (< (len args) 2) + (if (or (< (len args) 2) + (and (= (len args) 2) (form-empty-list? (at args 1)))) `(with-mode-2d-takes-a-camera-and-a-body) `(do (begin-mode-2d ~(at args 0)) ~@(form-rest args 1) @@ -97,7 +116,8 @@ ;; more here than anywhere: ending a 3D mode with end-mode-2d type-checks ;; fine and leaves the projection matrix wrong for everything after it. (defmacro with-mode-3d [args] - (if (< (len args) 2) + (if (or (< (len args) 2) + (and (= (len args) 2) (form-empty-list? (at args 1)))) `(with-mode-3d-takes-a-camera-and-a-body) `(do (begin-mode-3d ~(at args 0)) ~@(form-rest args 1) @@ -108,7 +128,8 @@ ;; that correction is the caller's and is deliberately not hidden here, since ;; it belongs with the draw and not with the mode. (defmacro with-texture-mode [args] - (if (< (len args) 2) + (if (or (< (len args) 2) + (and (= (len args) 2) (form-empty-list? (at args 1)))) `(with-texture-mode-takes-a-target-and-a-body) `(do (begin-texture-mode ~(at args 0)) ~@(form-rest args 1) @@ -118,7 +139,8 @@ ;; scalars rather than a Rectangle, because that is what BeginScissorMode ;; takes and this file is not the place to invent a second spelling. (defmacro with-scissor-mode [args] - (if (< (len args) 5) + (if (or (< (len args) 5) + (and (= (len args) 5) (form-empty-list? (at args 4)))) `(with-scissor-mode-takes-x-y-width-height-and-a-body) `(do (begin-scissor-mode ~(at args 0) ~(at args 1) ~(at args 2) ~(at args 3)) ~@(form-rest args 4)