@amritk/nish 0.11.0 → 0.13.0

package/scripts/postinstall.mjs

@@ -28,7 +28,7 @@
  *
  * **The compiler resolves the link itself as of 0.6.0** -- the real path of
  * whatever `argv[0]` named is a candidate for the package root
- * ([wp19 §5a](../docs/wp19-stage0-retirement.md) item 4, in `self/`) -- so this
+ * ([wp19 §5a](../docs/wp19-stage0-retirement.md) item 4, in `src/`) -- so this
  * `exec` is no longer what makes a copy work, and the reason it is still here is
  * the 91 ms above rather than the defect. It also still carries whoever never
  * ran this script: a shim npm linked and nothing swapped now finds its own
@@ -45,44 +45,54 @@
  * postinstall that can break `npm ci` is a worse bug than the startup cost it
  * exists to remove.
  */
-import fs from "node:fs";
-import path from "node:path";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
+import fs from "node:fs"
+import path from "node:path"
+import { createRequire } from "node:module"
+import { pathToFileURL } from "node:url"
 
-const root = path.resolve(import.meta.dirname, "..");
+const root = path.resolve(import.meta.dirname, "..")
 
 const swap = async () => {
   // A checkout, not an install. The repository is its own package, so `npm ci`
   // here installs this package's own optionalDependencies -- and without this
   // guard, the first `npm ci` after they are published would overwrite the
   // tracked `bin/nish` with a binary and leave the working tree dirty. The
-  // landmark is `self/compile.ts`, which is the check `scripts/bootstrap.sh`
-  // makes and is not in `files`; it used to be `src/launcher.ts`, which stopped
+  // landmark is `src/compile.ts`, which is the check `scripts/bootstrap.sh`
+  // makes and is not in `files`; it used to be stage0's `src/launcher.ts`, which stopped
   // being a landmark when the launcher moved into `bin/` and ships.
-  if (fs.existsSync(path.join(root, "self", "compile.ts"))) return "a checkout, so the shim stays";
+  if (fs.existsSync(path.join(root, "src", "compile.ts"))) {
+    return "a checkout, so the shim stays"
+  }
 
-  const shim = path.join(root, "bin", "nish");
-  if (!fs.existsSync(shim)) return "no bin/nish to replace";
+  const shim = path.join(root, "bin", "nish")
+  if (!fs.existsSync(shim)) {
+    return "no bin/nish to replace"
+  }
 
-  const packaging = path.join(root, "bin", "packaging.js");
-  if (!fs.existsSync(packaging)) return "bin/packaging.js is missing";
-  const { assetFor, platformPackageName } = await import(pathToFileURL(packaging).href);
-  const asset = assetFor(process.platform, process.arch);
-  if (asset === null) return `no prebuilt binary for ${process.platform}/${process.arch}`;
+  const packaging = path.join(root, "bin", "packaging.js")
+  if (!fs.existsSync(packaging)) {
+    return "bin/packaging.js is missing"
+  }
+  const { assetFor, platformPackageName } = await import(pathToFileURL(packaging).href)
+  const asset = assetFor(process.platform, process.arch)
+  if (asset === null) {
+    return `no prebuilt binary for ${process.platform}/${process.arch}`
+  }
 
   const name = platformPackageName(
     JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8")).name,
     asset
-  );
-  let binary;
+  )
+  let binary
   try {
-    const manifest = createRequire(import.meta.url).resolve(`${name}/package.json`);
-    binary = path.join(path.dirname(manifest), "bin", "nish");
+    const manifest = createRequire(import.meta.url).resolve(`${name}/package.json`)
+    binary = path.join(path.dirname(manifest), "bin", "nish")
   } catch {
-    return `${name} is not installed`;
+    return `${name} is not installed`
+  }
+  if (!fs.existsSync(binary)) {
+    return `${name} carries no bin/nish`
   }
-  if (!fs.existsSync(binary)) return `${name} carries no bin/nish`;
 
   // The absolute path is baked in at install time, which is the one thing this
   // gives up: a `node_modules` copied to a different path without a reinstall
@@ -99,35 +109,35 @@ const swap = async () => {
   // have ended up in, the shell would expand them. A home directory with a `$`
   // in it is unusual and entirely legal. In POSIX sh nothing is special inside
   // single quotes, so the only thing to handle is a single quote itself.
-  const shellQuote = (value) => `'${value.split("'").join(`'\\''`)}'`;
-  const target = shellQuote(binary);
+  const shellQuote = (value) => `'${value.split("'").join(`'\\''`)}'`
+  const target = shellQuote(binary)
   const script =
     "#!/bin/sh\n" +
     "# Written by scripts/postinstall.mjs. `npm rebuild` regenerates it.\n" +
     `if [ -x ${target} ]; then exec ${target} "$@"; fi\n` +
     // Exit 3 is this project's toolchain code: the compiler could not be run,
     // which is exactly what has happened (docs/wp12-release.md, "Exit codes").
-    'echo "nish: the prebuilt compiler is not where it was installed; run \'npm rebuild\' to repoint this" >&2\n' +
-    "exit 3\n";
-  const temp = `${shim}.${process.pid}.tmp`;
+    "echo \"nish: the prebuilt compiler is not where it was installed; run 'npm rebuild' to repoint this\" >&2\n" +
+    "exit 3\n"
+  const temp = `${shim}.${process.pid}.tmp`
   try {
-    fs.writeFileSync(temp, script);
-    fs.chmodSync(temp, 0o755);
-    fs.renameSync(temp, shim);
+    fs.writeFileSync(temp, script)
+    fs.chmodSync(temp, 0o755)
+    fs.renameSync(temp, shim)
   } catch (err) {
     try {
-      fs.rmSync(temp, { force: true });
+      fs.rmSync(temp, { force: true })
     } catch {
       // Nothing to do about it, and it is not worth a second message.
     }
-    throw err;
+    throw err
   }
-  return `bin/nish now execs the native compiler in ${name}`;
-};
+  return `bin/nish now execs the native compiler in ${name}`
+}
 
 try {
-  console.log(`nish: ${await swap()}`);
+  console.log(`nish: ${await swap()}`)
 } catch (err) {
   // Deliberately not an error: the shim is still there and still works.
-  console.log(`nish: keeping the node launcher (${err instanceof Error ? err.message : String(err)})`);
+  console.log(`nish: keeping the node launcher (${err instanceof Error ? err.message : String(err)})`)
 }

package/scripts/size-report.sh

@@ -51,13 +51,13 @@ text_sum() {                             # text_sum <object>: every .text* secti
 }
 sect() { size -A "$2" | awk -v s="$1" '$1 == s { print $2 }'; }
 "${CC:-clang}" -Oz -c runtime/runtime.c -o build/size/runtime.o
-"${CC:-clang}" -Oz -c runtime/runtime_os.c -o build/size/runtime_os.o
+"${CC:-clang}" -Oz -c runtime/runtime-os.c -o build/size/runtime_os.o
 row runtime "$(text_sum build/size/runtime.o)" \
   "clang -Oz -c runtime/runtime.c && size -A (.text*; budget 3584)"
 row runtime_os "$(text_sum build/size/runtime_os.o)" \
-  "clang -Oz -c runtime/runtime_os.c && size -A (.text*; budget 1280)"
+  "clang -Oz -c runtime/runtime-os.c && size -A (.text*; budget 1280)"
 row rodata "$(sect .rodata build/size/runtime.o)" "the core object's .rodata (no budget; the Ryu tables live here)"
-# `scripts/build.sh` compiles runtime_os.c beside any runtime.c it is handed, so naming the
+# `scripts/build.sh` compiles runtime-os.c beside any runtime.c it is handed, so naming the
 # core here builds the whole runtime -- and `--gc-sections` then drops whatever this module
 # never calls, which for `examples/add.ts` is all of it.
 for p in debug speed size; do

package/scripts/smoke.sh

@@ -17,7 +17,7 @@
 # link, or run with the expected status. Binaries and IR go to build/smoke/.
 # Needs clang on PATH.
 set -uo pipefail
-cd "$(dirname "$0")/.."
+cd "$(dirname "$0")/.." || exit
 
 examples=${1:-examples}
 out=build/smoke

package/std/README.md

@@ -1,10 +1,10 @@
 # `std/` — the standard library
 
 Nish modules written in Nish, for Nish programs to import. There is no magic
-here and — with two exceptions, `threads.ts` and `collections.ts` — nothing
-the compiler knows about: a module in this directory is an ordinary Nish source file, compiled as part of
+here and — with three exceptions, `threads.ts`, `collections.ts` and `map.ts` —
+nothing the compiler knows about: a module in this directory is an ordinary Nish source file, compiled as part of
 whatever program imports it, and subject to the same rules as `examples/` or
-`self/` ([`docs/LANGUAGE.md`](../docs/LANGUAGE.md) is the style guide).
+`src/` ([`docs/LANGUAGE.md`](../docs/LANGUAGE.md) is the style guide).
 
 | Module | What it is |
 | --- | --- |
@@ -12,7 +12,8 @@ whatever program imports it, and subject to the same rules as `examples/` or
 | [`text.ts`](./text.ts) | the string operations a program would otherwise write inline: `splitLines`, `splitWhitespace`, `trim` and its halves, `contains`, `replaceAll`, and `firstDifference` over two arrays of lines |
 | [`json.ts`](./json.ts) | `jsonField(object, name)`: the value of one field of one flat JSON object, which is the shape the compiler's own `--json` diagnostics have. A reader and not a parser — it answers text, answers `null` for a field that is not there, and does not validate |
 | [`pair.ts`](./pair.ts) | `Pair<A, B>`: an interface with `first` and `second`, for a function that answers two values from one call. A type and nothing else — the caller writes an object literal at the return — and for returning two values rather than storing them side by side |
-| [`collections.ts`](./collections.ts) | the global `Map<K, V>` and `Set<T>`: insertion-ordered tables whose buckets carry a hash fingerprint beside the entry index and whose entries keep their full hash, so every `get`, `set`, `add`, `has` and `delete` is one probe. `get` is not a method here: its `V | undefined` never crosses a call, so the compiler lowers it to `probe` and, where the key was found, `valueAt`. Nor are `keys()` and `values()`: an iterator is not a value, so a `for...of` over one is lowered to `walkOpen`, `walkNext`, `keyAt` or `valueAt`, and `walkClose`, and a count of live walks defers compaction until no loop is walking the table. A program never imports it: naming `Map` or `Set` loads it, and the compiler emits what a module uses of it into that module ([`docs/wp32-map.md`](../docs/wp32-map.md), [`docs/LANGUAGE.md`](../docs/LANGUAGE.md#map-and-set)). Its `hashKey` and `sameKey` are lowered by the compiler per key type |
+| [`collections.ts`](./collections.ts) | the global `Map<K, V>` and `Set<T>`: insertion-ordered tables whose buckets carry a hash fingerprint beside the entry index and whose entries keep their full hash, so every `get`, `set`, `add`, `has` and `delete` is one probe. `get` is not a method here: its `V | undefined` never crosses a call, so the compiler lowers it to `probe` and, where the key was found, `valueAt`. Nor are `keys()` and `values()`: an iterator is not a value, so a `for...of` over one is lowered to `walkOpen`, `walkNext`, `keyAt` or `valueAt`, and `walkClose`, and a count of live walks defers compaction until no loop is walking the table. A program never imports it: naming `Map` or `Set` loads it, and the compiler emits what a module uses of it into that module ([`docs/wp32-map.md`](../docs/wp32-map.md), [`docs/LANGUAGE.md`](../docs/LANGUAGE.md#map-and-set)). Its `hashKey`, `sameKey` and `storedKey` are lowered by the compiler per key type |
+| [`map.ts`](./map.ts) | `reserve(m, n)` and `getOrInsert(m, k, v)` for the global `Map`. Their bodies are the meaning, and what runs under Node: `reserve` does nothing, and `getOrInsert` is a `get`, and a `set` of `v` when the key was missing. Natively the compiler lowers every call in place — `reserve` to the table's `reserveSlots`, which grows the buckets once so that `n` entries fit without a rebuild, and `getOrInsert` to one `probe` and a `valueAt` or an `insertAt` through its answer — so, like `collections.ts`, it writes no `.ll` of its own ([`docs/wp32-map.md`](../docs/wp32-map.md) §9.2, [`docs/LANGUAGE.md`](../docs/LANGUAGE.md#map-and-set)) |
 | [`threads.ts`](./threads.ts) | `parallelMapInto(src, dst, f)` and `parallelReduce(src, f, identity)`: a function over every element of an array, on as many threads as the length is worth. Its bodies are the sequential meaning, which is what runs under Node; the compiler recognises the two templates by module and name, lowers the one loop in each onto `nish_parallel_range`, holds the function to the rules that make that safe, and compiles an importing program with `--threads` ([`docs/LANGUAGE.md`](../docs/LANGUAGE.md#data-parallelism-nishthreads)). `tests/link/par_*` are its programs |
 
 ## How a program imports it
@@ -64,12 +65,16 @@ reasons that are only true of it:
   package and is versioned with it, so "the `std/` beside this binary" is not a
   guess a resolver makes — it is the only `std/` that can be correct for the
   compiler reading it. No version can be skewed against it.
-- It **is** what Node resolves. `package.json` declares
-  `"./*": "./std/*.ts"` in `exports`, so `nish/text` is a package
-  self-reference: `import.meta.resolve("nish/text")` answers `std/text.ts`, and
-  `tsc` under `moduleResolution: node16` resolves it to the same file, which is
-  what gives an editor go-to-definition into the real source. The compiler
-  short-circuits to that answer rather than walking `node_modules` to reach it.
+- It **is** what Node and `tsc` resolve. The package is published as
+  `@amritk/nish`, so a bare `nish/text` is not a package self-reference on its
+  own; `runtime/nish.mjs`, the prelude a program runs under Node with
+  (`node --experimental-strip-types --import ./runtime/nish.mjs`), resolves
+  `nish/<module>` to `std/<module>.ts` beside itself, and the repository's
+  `tsconfig.json` maps `nish/*` to `./std/*`, which is what gives `tsc` and an
+  editor go-to-definition into the real source. `package.json` still declares
+  `"./*": "./std/*.ts"` in `exports`, so `@amritk/nish/text` reaches the same
+  file. The compiler short-circuits to that answer rather than walking
+  `node_modules` to reach it.
 
 So this is WP21's first slice rather than a detour around it: the spelling is
 the one WP21 specifies, and what is still missing is resolution for specifiers
@@ -125,7 +130,7 @@ that are *not* this package.
   stdout. `tests/link/std_text_f64` is the same corpus under
   `--number-mode f64`, which is where a module that spelled its widths and forgot
   a `toI32` is caught.
-- **`std/` is not on the compiler's dependency list.** Nothing in `self/`
+- **`std/` is not on the compiler's dependency list.** Nothing in `src/`
   imports it, and nothing should: the compiler is the thing that has to
   build before the library means anything.