diff --git a/.llm/BETA_7_SERIALIZATION_DATA_INTERCHANGE.md b/.llm/BETA_7_SERIALIZATION_DATA_INTERCHANGE.md new file mode 100644 index 0000000..beffe57 --- /dev/null +++ b/.llm/BETA_7_SERIALIZATION_DATA_INTERCHANGE.md @@ -0,0 +1,61 @@ +# 1.0.0-beta.7 Serialization And Data Interchange Target + +Status: released as `1.0.0-beta.7` on 2026-05-22. + +`1.0.0-beta.7` targets a deliberately narrow serialization/data-interchange +foundation after the beta.6 networking slice. The goal is compact JSON text +construction for CLI, file, and loopback-network programs without pretending +that Slovo already has the collections and string APIs needed for a complete +JSON library. + +## Slovo Source Surface + +The staged source facade is `lib/std/json.slo`, importable explicitly as +`std.json`. + +Exported helpers: + +- `quote_string : (string) -> string` +- `null_value : () -> string` +- `bool_value : (bool) -> string` +- `i32_value : (i32) -> string` +- `u32_value : (u32) -> string` +- `i64_value : (i64) -> string` +- `u64_value : (u64) -> string` +- `f64_value : (f64) -> string` +- `field_string`, `field_bool`, `field_i32`, `field_u32`, `field_i64`, + `field_u64`, `field_f64`, and `field_null` +- `array0`, `array1`, `array2`, `array3` +- `object0`, `object1`, `object2`, `object3` + +The array and object helpers accept already-encoded JSON text fragments. They +are compact construction helpers, not recursive data structures. + +## Runtime Call + +The facade wraps one compiler-known runtime call: + +- `std.json.quote_string(value string) -> string` + +The hosted runtime symbol is `__glagol_json_quote_string`. It returns a +complete compact JSON string literal including surrounding quotes. It escapes +quote, backslash, newline, tab, carriage return, backspace, form feed, and +other control bytes. Allocation failure uses the existing string allocation +trap. + +## Fixtures And Benchmarks + +- `examples/projects/std-import-json/` exercises explicit `std.json` source + import. +- `examples/projects/std-layout-local-json/` mirrors the facade as a local + module fixture and keeps the source-search contract explicit. +- `benchmarks/json-quote-loop/` adds a local-machine timing scaffold for JSON + string quoting across Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL. + +## Deferrals + +This scope does not add JSON parsing, recursive JSON values, maps/sets, generic +collections, source-level byte/character scanners, slicing, streaming encoders, +schema validation, Unicode normalization, embedded NUL support in the current +null-terminated runtime string ABI, stable runtime helper symbols, stable +ABI/layout/ownership guarantees, or a stable standard-library API freeze. diff --git a/.llm/ROADMAP_TO_STABLE.md b/.llm/ROADMAP_TO_STABLE.md index 0000547..7141ed5 100644 --- a/.llm/ROADMAP_TO_STABLE.md +++ b/.llm/ROADMAP_TO_STABLE.md @@ -28,7 +28,9 @@ implementation scope. concrete numeric completeness. 5. Expand package/workspace discipline before remote registry work. 6. Add networking only after resource/error policy is coherent. -7. Add serialization/data-interchange helpers before richer network libraries. +7. Add serialization/data-interchange helpers before richer network libraries + (released in `1.0.0-beta.7` with compact JSON text construction and JSON + string quoting). 8. Design generics and collection unification from real stdlib duplication pressure. 9. Add editor-facing diagnostics, watch mode, and generated documentation diff --git a/.llm/reviews/BETA_7_RELEASE_REVIEW.md b/.llm/reviews/BETA_7_RELEASE_REVIEW.md new file mode 100644 index 0000000..7fb9d67 --- /dev/null +++ b/.llm/reviews/BETA_7_RELEASE_REVIEW.md @@ -0,0 +1,37 @@ +# 1.0.0-beta.7 Release Review + +Date: 2026-05-22 + +Scope: serialization and data-interchange foundation. + +## Verdict + +`1.0.0-beta.7` is a coherent beta follow-up slice. The release adds a narrow +runtime-backed JSON string quoting primitive, a source-authored `std/json.slo` +facade, explicit std/local example projects, and a `json-quote-loop` benchmark +scaffold without claiming full JSON parsing, recursive JSON values, maps, +schema validation, or streaming encoders. + +## Review Notes + +- The new compiler-known call is intentionally small: + `std.json.quote_string(value string) -> string` lowers to + `__glagol_json_quote_string` and is listed in unsupported-call diagnostics. +- The source facade composes existing string and numeric helpers and keeps + object/array helpers limited to small fixed arities over already-encoded JSON + fragments. +- The local and std import fixtures preserve the current explicit-import + standard-library discipline. +- The benchmark scaffold is suitable as a local regression/comparison harness, + but the whitepapers still treat the exp-123 nine-row table as the current + published numeric baseline until fresh full-suite timing is rerun. +- The hosted runtime escaping path covers quotes, backslashes, standard JSON + control escapes, and `\u00XX` for remaining control bytes. + +## Remaining Deferred Work + +- JSON parsing and recursive JSON value modeling. +- Maps/sets or generic collection-backed object construction. +- Streaming encoders and schema-oriented validation. +- Unicode normalization or code point policy beyond byte-preserving string + literal emission. diff --git a/README.md b/README.md index 32681fe..cfff8b4 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ This repository is the canonical public monorepo for the language design, standard library source, compiler, runtime, examples, benchmarks, and technical documents. -Current release: `1.0.0-beta.6`. +Current release: `1.0.0-beta.7`. ## Repository Layout @@ -24,13 +24,14 @@ scripts/ local release and document tooling ## Beta Scope -`1.0.0-beta.6` keeps the `1.0.0-beta` language baseline, includes the +`1.0.0-beta.7` keeps the `1.0.0-beta` language baseline, includes the `1.0.0-beta.1` tooling/install hardening slice, the `1.0.0-beta.2` runtime/resource foundation bundle, the `1.0.0-beta.3` standard-library stabilization bundle, the `1.0.0-beta.4` language-usability diagnostics bundle, the `1.0.0-beta.5` local package/workspace discipline bundle, and the -`1.0.0-beta.6` loopback networking foundation. The language baseline supports -practical local command-line programs and libraries with: +`1.0.0-beta.6` loopback networking foundation, plus the `1.0.0-beta.7` +serialization/data-interchange foundation. The language baseline supports +practical local command-line, file, and loopback-network programs with: - modules, explicit imports, packages, and local workspaces - `new`, `check`, `fmt`, `test`, `doc`, and `build` @@ -40,6 +41,7 @@ practical local command-line programs and libraries with: - explicit `std/*.slo` imports from `lib/std`, installed `share/slovo/std`, or `SLOVO_STD_PATH` - beta-scoped loopback TCP handles through `std.net` +- JSON string quoting and compact JSON text construction through `std.json` - hosted native builds through LLVM IR, Clang, and `runtime/runtime.c` Still deferred before stable: generics, maps/sets, broad package registry @@ -177,6 +179,21 @@ This is not a general networking stack. DNS, TLS, UDP, non-loopback binding, async IO, HTTP frameworks, rich host-error ADTs, stable socket ABI/layout, and automatic resource ownership remain deferred. +## 1.0.0-beta.7 Serialization And Data Interchange + +The `1.0.0-beta.7` release adds a narrow JSON text-construction foundation: + +- compiler-known `std.json.quote_string` for deterministic compact JSON string + quoting +- `lib/std/json.slo` source helpers for scalar values, fields, small arrays, + and small objects +- explicit std/local JSON example projects and a `json-quote-loop` benchmark + scaffold + +This is not a complete JSON library. Full parsing, recursive JSON values, +maps/sets, streaming encoders, schema validation, Unicode normalization, and a +stable data-interchange API freeze remain deferred. + ## Documentation - [Language Manifest](docs/language/MANIFEST.md) diff --git a/benchmarks/json-quote-loop/.gitignore b/benchmarks/json-quote-loop/.gitignore new file mode 100644 index 0000000..567609b --- /dev/null +++ b/benchmarks/json-quote-loop/.gitignore @@ -0,0 +1 @@ +build/ diff --git a/benchmarks/json-quote-loop/README.md b/benchmarks/json-quote-loop/README.md new file mode 100644 index 0000000..325dd7c --- /dev/null +++ b/benchmarks/json-quote-loop/README.md @@ -0,0 +1,71 @@ +# JSON Quote Loop Benchmark Scaffold + +Release: `1.0.0-beta.7`. + +This benchmark compares compact JSON string quoting plus checksum accumulation +across Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL on the same +machine. It is same machine local evidence only. + +It is not a published benchmark result, performance threshold, optimizer +claim, or cross-machine comparison. + +## Files + +- `src/main.slo`: Slovo project benchmark fixture +- `c/json_quote_loop.c`: C comparison implementation +- `rust/json_quote_loop.rs`: Rust comparison implementation +- `python/json_quote_loop.py`: Python comparison implementation +- `clojure/json_quote_loop.clj`: Clojure comparison implementation +- `common-lisp/json_quote_loop.lisp`: Common Lisp/SBCL comparison implementation +- `run.py`: build/run/timing harness + +All implementations print checksum `15000001` for loop count `1000000` and +target string `slo"vo\path`. Hot-loop mode uses loop count `10000000` and +checksum `150000001`. + +## Commands + +Run from the repository root: + +```bash +python3 benchmarks/json-quote-loop/run.py --list +python3 benchmarks/json-quote-loop/run.py --dry-run +python3 benchmarks/json-quote-loop/run.py --only python --repeats 3 --warmups 1 +python3 benchmarks/json-quote-loop/run.py --mode hot-loop --only slovo --only c --only rust +``` + +To include Slovo, build or point at a Glagol binary and make sure host Clang is +available: + +```bash +cargo build --manifest-path compiler/Cargo.toml --bin glagol +python3 benchmarks/json-quote-loop/run.py --glagol compiler/target/debug/glagol +``` + +The runner skips missing C/Rust/Slovo/Clojure/SBCL toolchains where possible. +Use `--only` multiple times to select implementations: + +```bash +python3 benchmarks/json-quote-loop/run.py --only slovo --only c --only rust --only clojure --only common_lisp +``` + +Clojure is detected with `clojure` on PATH, `CLOJURE`, or `CLOJURE_JAR`. +Common Lisp is detected with `sbcl` on PATH, `SBCL`, or `--sbcl`. + +## Comparison Method + +- The runner builds each implementation once before timing. The reported + numbers measure execution only, not compile time. +- Slovo timings use `glagol build`, which currently lowers to LLVM and then + invokes host `clang -O2` with `runtime/runtime.c`. +- C timings use `clang -O2 -std=c11`. +- Rust timings use `rustc -C opt-level=3 -C debuginfo=0`. +- The measured loop quotes one runtime-supplied ASCII string containing a + quote and a backslash, then accumulates the quoted byte length. + +Timing is cold-process local-machine evidence only. Clojure timings include +JVM and Clojure startup, while Common Lisp timings include SBCL script +startup. + +Hot-loop mode is startup-amortized local evidence. It runs a larger loop count +and reports total time plus normalized time for the base `1000000` loop count. diff --git a/benchmarks/json-quote-loop/benchmark.json b/benchmarks/json-quote-loop/benchmark.json new file mode 100644 index 0000000..3db994f --- /dev/null +++ b/benchmarks/json-quote-loop/benchmark.json @@ -0,0 +1,11 @@ +{ + "benchmark": "json-quote-loop", + "source_stem": "json_quote_loop", + "loop_count": 1000000, + "expected_checksum": "15000001", + "stdin": "1000000\n", + "hot_loop_count": 10000000, + "hot_expected_checksum": "150000001", + "hot_stdin": "10000000\n", + "run_args": ["slo\"vo\\path"] +} diff --git a/benchmarks/json-quote-loop/c/json_quote_loop.c b/benchmarks/json-quote-loop/c/json_quote_loop.c new file mode 100644 index 0000000..ee14283 --- /dev/null +++ b/benchmarks/json-quote-loop/c/json_quote_loop.c @@ -0,0 +1,118 @@ +#include +#include +#include +#include + +#define LOOP_COUNT 1000000 +#define EXPECTED_CHECKSUM 15000001 + +static int32_t configured_loop_count(void) { + int32_t value = LOOP_COUNT; + if (scanf("%d", &value) != 1 || value <= 0) { + return LOOP_COUNT; + } + return value; +} + +static const char *configured_target(int argc, char **argv) { + return argc > 1 ? argv[1] : "slo\"vo\\path"; +} + +static char json_hex_digit(unsigned char value) { + return value < 10 ? (char)('0' + value) : (char)('A' + (value - 10)); +} + +static char *quote_json_string(const char *text) { + size_t len = 2; + for (const unsigned char *cursor = (const unsigned char *)text; *cursor != '\0'; cursor++) { + switch (*cursor) { + case '"': + case '\\': + case '\n': + case '\t': + case '\r': + case '\b': + case '\f': + len += 2; + break; + default: + len += *cursor < 0x20 ? 6 : 1; + break; + } + } + + char *out = malloc(len + 1); + if (out == NULL) { + exit(2); + } + + char *write = out; + *write++ = '"'; + for (const unsigned char *cursor = (const unsigned char *)text; *cursor != '\0'; cursor++) { + switch (*cursor) { + case '"': + *write++ = '\\'; + *write++ = '"'; + break; + case '\\': + *write++ = '\\'; + *write++ = '\\'; + break; + case '\n': + *write++ = '\\'; + *write++ = 'n'; + break; + case '\t': + *write++ = '\\'; + *write++ = 't'; + break; + case '\r': + *write++ = '\\'; + *write++ = 'r'; + break; + case '\b': + *write++ = '\\'; + *write++ = 'b'; + break; + case '\f': + *write++ = '\\'; + *write++ = 'f'; + break; + default: + if (*cursor < 0x20) { + *write++ = '\\'; + *write++ = 'u'; + *write++ = '0'; + *write++ = '0'; + *write++ = json_hex_digit((unsigned char)(*cursor >> 4)); + *write++ = json_hex_digit((unsigned char)(*cursor & 0x0F)); + } else { + *write++ = (char)*cursor; + } + break; + } + } + *write++ = '"'; + *write = '\0'; + return out; +} + +static int32_t json_quote_loop(int32_t limit, const char *target) { + int32_t i = 0; + int32_t acc = 1; + + while (i < limit) { + char *quoted = quote_json_string(target); + acc += (int32_t)strlen(quoted); + free(quoted); + i += 1; + } + + return acc; +} + +int main(int argc, char **argv) { + int32_t result = json_quote_loop(configured_loop_count(), configured_target(argc, argv)); + printf("%d\n", result); + return result == EXPECTED_CHECKSUM ? 0 : 1; +} diff --git a/benchmarks/json-quote-loop/clojure/json_quote_loop.clj b/benchmarks/json-quote-loop/clojure/json_quote_loop.clj new file mode 100644 index 0000000..ee97af6 --- /dev/null +++ b/benchmarks/json-quote-loop/clojure/json_quote_loop.clj @@ -0,0 +1,42 @@ +(set! *warn-on-reflection* true) +(set! *unchecked-math* :warn-on-boxed) + +(def loop-count 1000000) +(def expected-checksum 15000001) + +(defn configured-loop-count [] + (try + (let [line (read-line) + value (Integer/parseInt (.trim ^String line))] + (if (pos? value) value loop-count)) + (catch Exception _ + loop-count))) + +(defn configured-target [] + (or (first *command-line-args*) "slo\"vo\\path")) + +(defn quote-json-string [^String value] + (let [builder (StringBuilder.)] + (.append builder \") + (dotimes [index (.length value)] + (let [ch (.charAt value index)] + (case ch + \" (.append builder "\\\"") + \\ (.append builder "\\\\") + \newline (.append builder "\\n") + \tab (.append builder "\\t") + \return (.append builder "\\r") + (.append builder ch)))) + (.append builder \") + (.toString builder))) + +(defn json-quote-loop [limit target] + (loop [i 0 + acc 1] + (if (< i limit) + (recur (inc i) (+ acc (.length ^String (quote-json-string target)))) + acc))) + +(let [result (json-quote-loop (configured-loop-count) (configured-target))] + (println result) + (System/exit (if (= result expected-checksum) 0 1))) diff --git a/benchmarks/json-quote-loop/common-lisp/json_quote_loop.lisp b/benchmarks/json-quote-loop/common-lisp/json_quote_loop.lisp new file mode 100644 index 0000000..97f894a --- /dev/null +++ b/benchmarks/json-quote-loop/common-lisp/json_quote_loop.lisp @@ -0,0 +1,47 @@ +(declaim (optimize (speed 3) (safety 0) (debug 0))) + +(defconstant +loop-count+ 1000000) +(defconstant +expected-checksum+ 15000001) + +(declaim (ftype (function () fixnum) configured-loop-count)) +(defun configured-loop-count () + (handler-case + (let ((line (read-line *standard-input* nil nil))) + (if line + (let ((value (parse-integer line :junk-allowed t))) + (if (> value 0) value +loop-count+)) + +loop-count+)) + (error () +loop-count+))) + +(declaim (ftype (function () string) configured-target)) +(defun configured-target () + (or (second sb-ext:*posix-argv*) "slo\"vo\\path")) + +(declaim (ftype (function (string) string) quote-json-string)) +(defun quote-json-string (value) + (with-output-to-string (out) + (write-char #\" out) + (loop for ch across value + do (case ch + (#\" (write-string "\\\"" out)) + (#\\ (write-string "\\\\" out)) + (#\Newline (write-string "\\n" out)) + (#\Tab (write-string "\\t" out)) + (#\Return (write-string "\\r" out)) + (otherwise (write-char ch out)))) + (write-char #\" out))) + +(declaim (ftype (function (fixnum string) fixnum) json-quote-loop)) +(defun json-quote-loop (limit target) + (declare (type fixnum limit) + (type string target)) + (loop with i of-type fixnum = 0 + with acc of-type fixnum = 1 + while (< i limit) + do (setf acc (+ acc (length (quote-json-string target))) + i (+ i 1)) + finally (return acc))) + +(let ((result (json-quote-loop (configured-loop-count) (configured-target)))) + (format t "~D~%" result) + (sb-ext:exit :code (if (= result +expected-checksum+) 0 1))) diff --git a/benchmarks/json-quote-loop/python/json_quote_loop.py b/benchmarks/json-quote-loop/python/json_quote_loop.py new file mode 100644 index 0000000..57b41de --- /dev/null +++ b/benchmarks/json-quote-loop/python/json_quote_loop.py @@ -0,0 +1,53 @@ +import sys + + +LOOP_COUNT = 1_000_000 +EXPECTED_CHECKSUM = 15_000_001 + + +def configured_loop_count() -> int: + try: + value = int(input().strip()) + except (EOFError, ValueError): + return LOOP_COUNT + + return value if value > 0 else LOOP_COUNT + + +def configured_target() -> str: + return sys.argv[1] if len(sys.argv) > 1 else 'slo"vo\\path' + + +def quote_json_string(value: str) -> str: + return ( + '"' + + value.replace("\\", "\\\\") + .replace('"', '\\"') + .replace("\n", "\\n") + .replace("\t", "\\t") + .replace("\r", "\\r") + .replace("\b", "\\b") + .replace("\f", "\\f") + + '"' + ) + + +def json_quote_loop(limit: int, target: str) -> int: + i = 0 + acc = 1 + + while i < limit: + acc += len(quote_json_string(target)) + i += 1 + + return acc + + +def main() -> int: + result = json_quote_loop(configured_loop_count(), configured_target()) + print(result) + return 0 if result == EXPECTED_CHECKSUM else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/benchmarks/json-quote-loop/run.py b/benchmarks/json-quote-loop/run.py new file mode 100644 index 0000000..23b0d11 --- /dev/null +++ b/benchmarks/json-quote-loop/run.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python3 +"""Run the local json-quote-loop benchmark scaffold.""" + +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) + +from runner import main + + +if __name__ == "__main__": + raise SystemExit(main(Path(__file__).resolve().parent, sys.argv[1:])) diff --git a/benchmarks/json-quote-loop/rust/json_quote_loop.rs b/benchmarks/json-quote-loop/rust/json_quote_loop.rs new file mode 100644 index 0000000..4ca27b4 --- /dev/null +++ b/benchmarks/json-quote-loop/rust/json_quote_loop.rs @@ -0,0 +1,62 @@ +use std::io::Read; + +const LOOP_COUNT: i32 = 1_000_000; +const EXPECTED_CHECKSUM: i32 = 15_000_001; + +fn configured_loop_count() -> i32 { + let mut input = String::new(); + if std::io::stdin().read_to_string(&mut input).is_err() { + return LOOP_COUNT; + } + + input + .trim() + .parse::() + .ok() + .filter(|value| *value > 0) + .unwrap_or(LOOP_COUNT) +} + +fn configured_target() -> String { + std::env::args() + .nth(1) + .unwrap_or_else(|| "slo\"vo\\path".to_string()) +} + +fn quote_json_string(value: &str) -> String { + let mut out = String::with_capacity(value.len() + 2); + out.push('"'); + for ch in value.chars() { + match ch { + '"' => out.push_str("\\\""), + '\\' => out.push_str("\\\\"), + '\n' => out.push_str("\\n"), + '\t' => out.push_str("\\t"), + '\r' => out.push_str("\\r"), + '\u{08}' => out.push_str("\\b"), + '\u{0c}' => out.push_str("\\f"), + _ => out.push(ch), + } + } + out.push('"'); + out +} + +fn json_quote_loop(limit: i32, target: &str) -> i32 { + let mut i = 0; + let mut acc = 1; + + while i < limit { + acc += quote_json_string(target).len() as i32; + i += 1; + } + + acc +} + +fn main() { + let target = configured_target(); + let result = json_quote_loop(configured_loop_count(), &target); + println!("{}", result); + std::process::exit(if result == EXPECTED_CHECKSUM { 0 } else { 1 }); +} diff --git a/benchmarks/json-quote-loop/slovo.toml b/benchmarks/json-quote-loop/slovo.toml new file mode 100644 index 0000000..d86172f --- /dev/null +++ b/benchmarks/json-quote-loop/slovo.toml @@ -0,0 +1,4 @@ +[project] +name = "json-quote-loop" +source_root = "src" +entry = "main" diff --git a/benchmarks/json-quote-loop/src/main.slo b/benchmarks/json-quote-loop/src/main.slo new file mode 100644 index 0000000..7927a7b --- /dev/null +++ b/benchmarks/json-quote-loop/src/main.slo @@ -0,0 +1,56 @@ +; Benchmark scaffold fixture for local-machine JSON string quoting comparisons only. +; Keep LOOP_COUNT and EXPECTED_CHECKSUM aligned with the C/Rust/Python fixtures. +; The runner supplies the target through argv and the loop count through stdin +; or argv so the quoting path stays runtime-configured. + +(module main) + +(fn loop_count () -> i32 + 1000000) + +(fn expected_checksum () -> i32 + 15000001) + +(fn parse_stdin_loop_count () -> (result i32 i32) + (let input (result string i32) (std.io.read_stdin_result)) + (match input + ((ok text) + (std.string.parse_i32_result text)) + ((err code) + (err i32 i32 code)))) + +(fn parse_arg_loop_count () -> (result i32 i32) + (std.string.parse_i32_result (std.process.arg 2))) + +(fn configured_stdin_loop_count () -> i32 + (let parsed_stdin (result i32 i32) (parse_stdin_loop_count)) + (if (is_ok parsed_stdin) + (unwrap_ok parsed_stdin) + (loop_count))) + +(fn configured_loop_count () -> i32 + (let parsed_arg (result i32 i32) (parse_arg_loop_count)) + (if (is_ok parsed_arg) + (unwrap_ok parsed_arg) + (configured_stdin_loop_count))) + +(fn target_text () -> string + (std.process.arg 1)) + +(fn json_quote_loop ((limit i32) (target string)) -> i32 + (var i i32 0) + (var acc i32 1) + (while (< i limit) + (set acc (+ acc (std.string.len (std.json.quote_string target)))) + (set i (+ i 1))) + acc) + +(fn main () -> i32 + (let result i32 (json_quote_loop (configured_loop_count) (target_text))) + (std.io.print_i32 result) + (if (= result (expected_checksum)) + 0 + 1)) + +(test "json quote loop checksum is deterministic" + (= (json_quote_loop 3 "slo\"vo\\path") 46)) diff --git a/compiler/Cargo.lock b/compiler/Cargo.lock index 0549084..de8c2b7 100644 --- a/compiler/Cargo.lock +++ b/compiler/Cargo.lock @@ -4,4 +4,4 @@ version = 3 [[package]] name = "glagol" -version = "1.0.0-beta.6" +version = "1.0.0-beta.7" diff --git a/compiler/Cargo.toml b/compiler/Cargo.toml index 3274b80..4d0ebd8 100644 --- a/compiler/Cargo.toml +++ b/compiler/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "glagol" -version = "1.0.0-beta.6" +version = "1.0.0-beta.7" edition = "2021" description = "Glagol, the first compiler for the Slovo language" license = "MIT OR Apache-2.0" diff --git a/compiler/src/llvm.rs b/compiler/src/llvm.rs index b7edf49..a362776 100644 --- a/compiler/src/llvm.rs +++ b/compiler/src/llvm.rs @@ -32,6 +32,7 @@ pub fn emit(_file: &str, program: &CheckedProgram) -> Result String { text } +fn quote_json_string_value(value: &str) -> String { + let mut quoted = String::with_capacity(value.len() + 2); + quoted.push('"'); + for byte in value.bytes() { + match byte { + b'"' => quoted.push_str("\\\""), + b'\\' => quoted.push_str("\\\\"), + b'\n' => quoted.push_str("\\n"), + b'\t' => quoted.push_str("\\t"), + b'\r' => quoted.push_str("\\r"), + 0x08 => quoted.push_str("\\b"), + 0x0c => quoted.push_str("\\f"), + 0x00..=0x1f => quoted.push_str(&format!("\\u{byte:04X}")), + _ => quoted.push(byte as char), + } + } + quoted.push('"'); + quoted +} + fn eval_expr( file: &str, expr: &TExpr, @@ -2108,6 +2128,24 @@ fn eval_expr( }; return Ok(Value::String(format!("{}{}", left, right))); } + if runtime_symbol == "__glagol_json_quote_string" { + let Some(arg) = args.first() else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.json.quote_string` calls", + )); + }; + let value = eval_expr(file, arg, locals, functions, foreign_imports, depth)?; + let Some(value) = value.as_string() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.json.quote_string` on non-string values", + )); + }; + return Ok(Value::String(quote_json_string_value(value))); + } if runtime_symbol == "__glagol_string_parse_i32_result" { let Some(arg) = args.first() else { return Err(unsupported_test_expr( diff --git a/compiler/tests/benchmark_math_loop_scaffold.rs b/compiler/tests/benchmark_math_loop_scaffold.rs index 01c84f5..9c04858 100644 --- a/compiler/tests/benchmark_math_loop_scaffold.rs +++ b/compiler/tests/benchmark_math_loop_scaffold.rs @@ -154,6 +154,7 @@ fn benchmark_roots() -> Vec { root.join("math-loop"), root.join("branch-loop"), root.join("parse-loop"), + root.join("json-quote-loop"), root.join("array-index-loop"), root.join("string-eq-loop"), root.join("array-struct-field-loop"), diff --git a/compiler/tests/promotion_gate.rs b/compiler/tests/promotion_gate.rs index cfae030..55a25cb 100644 --- a/compiler/tests/promotion_gate.rs +++ b/compiler/tests/promotion_gate.rs @@ -1163,6 +1163,43 @@ const STANDARD_NET_RUNTIME_NAMES: &[&str] = &[ "std.net.tcp_close_result", ]; +const STANDARD_JSON_SOURCE_FACADE_ALPHA: &[&str] = &[ + "quote_string", + "null_value", + "bool_value", + "i32_value", + "u32_value", + "i64_value", + "u64_value", + "f64_value", + "field_string", + "field_bool", + "field_i32", + "field_u32", + "field_i64", + "field_u64", + "field_f64", + "field_null", + "array0", + "array1", + "array2", + "array3", + "object0", + "object1", + "object2", + "object3", +]; + +const STANDARD_JSON_RUNTIME_NAMES: &[&str] = &[ + "std.json.quote_string", + "std.string.concat", + "std.num.i32_to_string", + "std.num.u32_to_string", + "std.num.i64_to_string", + "std.num.u64_to_string", + "std.num.f64_to_string", +]; + const STANDARD_PROCESS_SOURCE_FACADE_ALPHA: &[&str] = &[ "argc", "arg", @@ -1738,6 +1775,7 @@ fn promotion_gate_artifacts_are_aligned() { let glagol_project_std_layout_local_env = repo.join("examples/projects/std-layout-local-env"); let glagol_project_std_layout_local_fs = repo.join("examples/projects/std-layout-local-fs"); let glagol_project_std_layout_local_net = repo.join("examples/projects/std-layout-local-net"); + let glagol_project_std_layout_local_json = repo.join("examples/projects/std-layout-local-json"); let glagol_project_std_layout_local_io = repo.join("examples/projects/std-layout-local-io"); let glagol_project_std_layout_local_cli = repo.join("examples/projects/std-layout-local-cli"); let glagol_project_std_layout_local_vec_i32 = @@ -1758,6 +1796,7 @@ fn promotion_gate_artifacts_are_aligned() { let glagol_project_std_import_env = repo.join("examples/projects/std-import-env"); let glagol_project_std_import_fs = repo.join("examples/projects/std-import-fs"); let glagol_project_std_import_net = repo.join("examples/projects/std-import-net"); + let glagol_project_std_import_json = repo.join("examples/projects/std-import-json"); let glagol_project_std_import_process = repo.join("examples/projects/std-import-process"); let glagol_project_std_import_string = repo.join("examples/projects/std-import-string"); let glagol_project_std_import_num = repo.join("examples/projects/std-import-num"); @@ -1772,6 +1811,7 @@ fn promotion_gate_artifacts_are_aligned() { let glagol_benchmark_math_loop = repo.join("benchmarks/math-loop"); let glagol_benchmark_branch_loop = repo.join("benchmarks/branch-loop"); let glagol_benchmark_parse_loop = repo.join("benchmarks/parse-loop"); + let glagol_benchmark_json_quote_loop = repo.join("benchmarks/json-quote-loop"); let glagol_benchmark_array_index_loop = repo.join("benchmarks/array-index-loop"); let glagol_benchmark_string_eq_loop = repo.join("benchmarks/string-eq-loop"); let glagol_benchmark_array_struct_field_loop = repo.join("benchmarks/array-struct-field-loop"); @@ -2110,6 +2150,7 @@ fn promotion_gate_artifacts_are_aligned() { assert_project_std_import_env_tooling_matches_fixture(&glagol_project_std_import_env); assert_project_std_import_fs_tooling_matches_fixture(&glagol_project_std_import_fs); assert_project_std_import_net_tooling_matches_fixture(&glagol_project_std_import_net); + assert_project_std_import_json_tooling_matches_fixture(&glagol_project_std_import_json); assert_project_std_import_process_tooling_matches_fixture(&glagol_project_std_import_process); assert_project_std_import_string_tooling_matches_fixture(&glagol_project_std_import_string); assert_project_std_import_num_tooling_matches_fixture(&glagol_project_std_import_num); @@ -2151,6 +2192,9 @@ fn promotion_gate_artifacts_are_aligned() { assert_project_std_layout_local_net_tooling_matches_fixture( &glagol_project_std_layout_local_net, ); + assert_project_std_layout_local_json_tooling_matches_fixture( + &glagol_project_std_layout_local_json, + ); assert_project_std_layout_local_io_tooling_matches_fixture(&glagol_project_std_layout_local_io); assert_project_std_layout_local_cli_tooling_matches_fixture( &glagol_project_std_layout_local_cli, @@ -2181,6 +2225,11 @@ fn promotion_gate_artifacts_are_aligned() { "parse-loop", "parse_loop", ); + assert_named_benchmark_scaffold_is_promotable( + &glagol_benchmark_json_quote_loop, + "json-quote-loop", + "json_quote_loop", + ); assert_named_benchmark_scaffold_is_promotable( &glagol_benchmark_array_index_loop, "array-index-loop", @@ -3337,6 +3386,7 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) { std_dir.join("env.slo"), std_dir.join("fs.slo"), std_dir.join("io.slo"), + std_dir.join("json.slo"), std_dir.join("math.slo"), std_dir.join("net.slo"), std_dir.join("num.slo"), @@ -3368,6 +3418,7 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) { "fs.slo", "math.slo", "net.slo", + "json.slo", "num.slo", "option.slo", "process.slo", @@ -3385,6 +3436,7 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) { && file != "env.slo" && file != "fs.slo" && file != "io.slo" + && file != "json.slo" && file != "process.slo" && file != "string.slo" && file != "vec_i32.slo" @@ -4274,6 +4326,54 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) { helper ); } + + let local_json = repo.join("examples/projects/std-layout-local-json/src/json.slo"); + let slovo_json = read(&std_dir.join("json.slo")); + let glagol_json = read(&local_json); + assert!( + slovo_json.contains("(module json") && glagol_json.contains("(module json"), + "both Slovo std/json.slo and the Glagol local fixture should use explicit `json` module source shape" + ); + for runtime_name in STANDARD_JSON_RUNTIME_NAMES { + assert!( + slovo_json.contains(runtime_name) && glagol_json.contains(runtime_name), + "standard json facade must stay backed by `{}`", + runtime_name + ); + } + assert_std_only_contains( + &slovo_json, + STANDARD_JSON_RUNTIME_NAMES, + "Slovo std/json.slo must not introduce other compiler-known std names", + ); + assert_std_only_contains( + &glagol_json, + STANDARD_JSON_RUNTIME_NAMES, + "Glagol local json fixture must not introduce other compiler-known std names", + ); + for source in [&slovo_json, &glagol_json] { + assert!( + !source.contains("parse") + && !source.contains("token") + && !source.contains("map") + && !source.contains("unicode") + && !source.contains("schema") + && !source.contains("stream"), + "standard json facade must not claim deferred parser or richer data policies" + ); + } + for helper in STANDARD_JSON_SOURCE_FACADE_ALPHA { + assert!( + slovo_json.contains(&format!("(fn {} ", helper)), + "Slovo std/json.slo is missing beta7 facade `{}`", + helper + ); + assert!( + glagol_json.contains(&format!("(fn {} ", helper)), + "Glagol local json fixture is missing beta7 facade `{}`", + helper + ); + } } fn assert_source_shaped_file(path: &Path) { @@ -7107,6 +7207,22 @@ fn assert_project_std_import_net_tooling_matches_fixture(project: &Path) { ); } +fn assert_project_std_import_json_tooling_matches_fixture(project: &Path) { + assert_project_std_import_host_facade_tooling_matches_fixture( + project, + "json", + STANDARD_JSON_SOURCE_FACADE_ALPHA, + concat!( + "test \"explicit std json quote escapes facade\" ... ok\n", + "test \"explicit std json scalar values facade\" ... ok\n", + "test \"explicit std json fields facade\" ... ok\n", + "test \"explicit std json arrays objects facade\" ... ok\n", + "test \"explicit std json facade all\" ... ok\n", + "5 test(s) passed\n", + ), + ); +} + fn assert_project_std_import_process_tooling_matches_fixture(project: &Path) { assert_project_std_import_host_facade_shape( project, @@ -9271,6 +9387,82 @@ fn assert_standard_net_source_facade_alpha(project: &Path) { } } +fn assert_project_std_layout_local_json_tooling_matches_fixture(project: &Path) { + assert!(project.join("slovo.toml").is_file()); + assert!(project.join("src/json.slo").is_file()); + assert!(project.join("src/main.slo").is_file()); + assert_standard_json_source_facade_alpha(project); + + let check = run_glagol([OsStr::new("check"), project.as_os_str()]); + assert_success_stdout(check, "", "std layout local json project check"); + + let test = run_glagol([OsStr::new("test"), project.as_os_str()]); + assert_success_stdout( + test, + concat!( + "test \"explicit local json quote escapes facade\" ... ok\n", + "test \"explicit local json scalar values facade\" ... ok\n", + "test \"explicit local json fields facade\" ... ok\n", + "test \"explicit local json arrays objects facade\" ... ok\n", + "test \"explicit local json facade all\" ... ok\n", + "5 test(s) passed\n", + ), + "std layout local json project test", + ); +} + +fn assert_standard_json_source_facade_alpha(project: &Path) { + let json_source = read(&project.join("src/json.slo")); + let main = read(&project.join("src/main.slo")); + + assert!( + json_source.starts_with("(module json (export "), + "local json fixture must stay an explicitly exported local module" + ); + assert!( + main.starts_with("(module main)\n\n(import json ("), + "local json fixture must stay an explicit local import" + ); + assert!( + !main.contains("(import std") && !main.contains("(import slovo.std"), + "standard json source facade fixture must not use automatic std imports" + ); + for runtime_name in STANDARD_JSON_RUNTIME_NAMES { + assert!( + json_source.contains(runtime_name), + "standard json source facade fixture must wrap or compose `{}`", + runtime_name + ); + } + assert_std_only_contains( + &json_source, + STANDARD_JSON_RUNTIME_NAMES, + "standard json source facade fixture must use only approved std runtime names directly", + ); + assert!( + !main.contains("std.") + && !json_source.contains("parse") + && !json_source.contains("token") + && !json_source.contains("map") + && !json_source.contains("unicode") + && !json_source.contains("schema") + && !json_source.contains("stream"), + "standard json source facade fixture must remain local and must not claim deferred JSON policies" + ); + for helper in STANDARD_JSON_SOURCE_FACADE_ALPHA { + assert!( + json_source.contains(&format!("(fn {} ", helper)), + "local json fixture is missing facade `{}`", + helper + ); + assert!( + main.contains(helper), + "main fixture import/use is missing facade `{}`", + helper + ); + } +} + fn assert_project_std_layout_local_io_tooling_matches_fixture(project: &Path) { assert!(project.join("slovo.toml").is_file()); assert!(project.join("src/io.slo").is_file()); diff --git a/compiler/tests/standard_json.rs b/compiler/tests/standard_json.rs new file mode 100644 index 0000000..7036634 --- /dev/null +++ b/compiler/tests/standard_json.rs @@ -0,0 +1,226 @@ +use std::{ + env, + ffi::OsStr, + fs, + path::{Path, PathBuf}, + process::{Command, Output}, + sync::atomic::{AtomicUsize, Ordering}, +}; + +static NEXT_FIXTURE_ID: AtomicUsize = AtomicUsize::new(0); + +#[test] +fn standard_json_lowers_to_private_runtime_helper() { + let fixture = write_fixture( + "lowering", + r#" +(module main) + +(fn main () -> i32 + (if (= (std.json.quote_string "slo\"vo") "\"slo\\\"vo\"") + 0 + 1)) +"#, + ); + let output = run_glagol([fixture.as_os_str()]); + assert_success("compile standard json lowering", &output); + let stdout = String::from_utf8_lossy(&output.stdout); + + assert!( + stdout.contains("declare ptr @__glagol_json_quote_string(ptr)") + && stdout.contains("call ptr @__glagol_json_quote_string(") + && !stdout.contains("@std.json.quote_string"), + "standard json LLVM shape drifted\nstdout:\n{}", + stdout + ); +} + +#[test] +fn test_runner_reports_deterministic_json_quoting() { + let fixture = write_fixture( + "test-runner", + r#" +(module main) + +(test "quote plain string" + (= (std.json.quote_string "slovo") "\"slovo\"")) + +(test "quote embedded quote" + (= (std.json.quote_string "slo\"vo") "\"slo\\\"vo\"")) + +(test "quote backslash" + (= (std.json.quote_string "slo\\vo") "\"slo\\\\vo\"")) + +(test "quote newline tab" + (= (std.json.quote_string "line\n\tnext") "\"line\\n\\tnext\"")) +"#, + ); + let output = run_glagol([OsStr::new("test"), fixture.as_os_str()]); + assert_success("run standard json tests", &output); + assert_eq!( + String::from_utf8_lossy(&output.stdout), + concat!( + "test \"quote plain string\" ... ok\n", + "test \"quote embedded quote\" ... ok\n", + "test \"quote backslash\" ... ok\n", + "test \"quote newline tab\" ... ok\n", + "4 test(s) passed\n", + ), + "standard json test runner stdout drifted" + ); +} + +#[test] +fn standard_json_diagnostics_cover_promoted_and_deferred_names() { + let cases = [ + ( + "quote-arity", + r#" +(module main) + +(fn main () -> i32 + (std.json.quote_string)) +"#, + "ArityMismatch", + ), + ( + "quote-type", + r#" +(module main) + +(fn main () -> i32 + (std.json.quote_string 42) + 0) +"#, + "TypeMismatch", + ), + ( + "parse-object-deferred", + r#" +(module main) + +(fn main () -> i32 + (std.json.parse_object_result "{}")) +"#, + "UnsupportedStandardLibraryCall", + ), + ( + "promoted-shadow", + r#" +(module main) + +(fn std.json.quote_string ((value string)) -> string + value) + +(fn main () -> i32 + (if (= (std.json.quote_string "x") "\"x\"") 0 1)) +"#, + "DuplicateFunction", + ), + ]; + + for (name, source, diagnostic) in cases { + let fixture = write_fixture(name, source); + let output = run_glagol([fixture.as_os_str()]); + let stdout = String::from_utf8_lossy(&output.stdout); + let stderr = String::from_utf8_lossy(&output.stderr); + + assert!( + !output.status.success(), + "compiler unexpectedly accepted `{}`\nstdout:\n{}\nstderr:\n{}", + name, + stdout, + stderr + ); + assert!( + stdout.is_empty(), + "rejected compile wrote stdout:\n{}", + stdout + ); + assert!( + stderr.contains(diagnostic), + "diagnostic `{}` was not reported for `{}`\nstderr:\n{}", + diagnostic, + name, + stderr + ); + } +} + +#[test] +fn hosted_json_quote_smoke_when_clang_is_available() { + if !clang_is_available() { + eprintln!("skipping standard json runtime smoke: set GLAGOL_CLANG or install clang"); + return; + } + + let fixture = write_fixture( + "hosted", + r#" +(module main) + +(fn main () -> i32 + (if (= (std.json.quote_string "line\nnext") "\"line\\nnext\"") + 0 + 1)) +"#, + ); + let binary = fixture.with_extension(env::consts::EXE_EXTENSION); + let build = run_glagol([ + OsStr::new("build"), + fixture.as_os_str(), + OsStr::new("-o"), + binary.as_os_str(), + ]); + assert_success("build standard json hosted smoke", &build); + + let run = Command::new(&binary) + .output() + .unwrap_or_else(|err| panic!("run `{}`: {}", binary.display(), err)); + assert_success("run standard json hosted smoke", &run); +} + +fn write_fixture(name: &str, source: &str) -> PathBuf { + let id = NEXT_FIXTURE_ID.fetch_add(1, Ordering::Relaxed); + let dir = env::temp_dir().join(format!("glagol-standard-json-{id}-{name}")); + fs::create_dir_all(&dir).unwrap_or_else(|err| panic!("create `{}`: {}", dir.display(), err)); + let path = dir.join("main.slo"); + fs::write(&path, source).unwrap_or_else(|err| panic!("write `{}`: {}", path.display(), err)); + path +} + +fn clang_is_available() -> bool { + if env::var_os("GLAGOL_CLANG").is_some() { + return true; + } + Command::new("clang") + .arg("--version") + .output() + .is_ok_and(|output| output.status.success()) +} + +fn run_glagol(args: I) -> Output +where + I: IntoIterator, + S: AsRef, +{ + Command::new(env!("CARGO_BIN_EXE_glagol")) + .args(args) + .current_dir(Path::new(env!("CARGO_MANIFEST_DIR"))) + .output() + .expect("run glagol") +} + +fn assert_success(context: &str, output: &Output) { + let stdout = String::from_utf8_lossy(&output.stdout); + let stderr = String::from_utf8_lossy(&output.stderr); + + assert!( + output.status.success(), + "{} failed\nstdout:\n{}\nstderr:\n{}", + context, + stdout, + stderr + ); + assert!(stderr.is_empty(), "{} wrote stderr:\n{}", context, stderr); +} diff --git a/compiler/tests/standard_json_source_facade_alpha.rs b/compiler/tests/standard_json_source_facade_alpha.rs new file mode 100644 index 0000000..b330242 --- /dev/null +++ b/compiler/tests/standard_json_source_facade_alpha.rs @@ -0,0 +1,249 @@ +use std::{ + ffi::OsStr, + fs, + path::Path, + process::{Command, Output}, +}; + +const EXPECTED_LOCAL_TEST_OUTPUT: &str = concat!( + "test \"explicit local json quote escapes facade\" ... ok\n", + "test \"explicit local json scalar values facade\" ... ok\n", + "test \"explicit local json fields facade\" ... ok\n", + "test \"explicit local json arrays objects facade\" ... ok\n", + "test \"explicit local json facade all\" ... ok\n", + "5 test(s) passed\n", +); + +const EXPECTED_STD_IMPORT_TEST_OUTPUT: &str = concat!( + "test \"explicit std json quote escapes facade\" ... ok\n", + "test \"explicit std json scalar values facade\" ... ok\n", + "test \"explicit std json fields facade\" ... ok\n", + "test \"explicit std json arrays objects facade\" ... ok\n", + "test \"explicit std json facade all\" ... ok\n", + "5 test(s) passed\n", +); + +const STANDARD_JSON_SOURCE_FACADE_ALPHA: &[&str] = &[ + "quote_string", + "null_value", + "bool_value", + "i32_value", + "u32_value", + "i64_value", + "u64_value", + "f64_value", + "field_string", + "field_bool", + "field_i32", + "field_u32", + "field_i64", + "field_u64", + "field_f64", + "field_null", + "array0", + "array1", + "array2", + "array3", + "object0", + "object1", + "object2", + "object3", +]; + +const STANDARD_JSON_RUNTIME_NAMES: &[&str] = &[ + "std.json.quote_string", + "std.string.concat", + "std.num.i32_to_string", + "std.num.u32_to_string", + "std.num.i64_to_string", + "std.num.u64_to_string", + "std.num.f64_to_string", +]; + +#[test] +fn standard_json_source_facade_project_checks_formats_and_tests() { + let project = + Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples/projects/std-layout-local-json"); + + assert_local_json_fixture_is_source_authored(&project); + + let fmt = run_glagol([ + OsStr::new("fmt"), + OsStr::new("--check"), + project.as_os_str(), + ]); + assert_success("std layout local json fmt --check", &fmt); + + let check = run_glagol([OsStr::new("check"), project.as_os_str()]); + assert_success_stdout(check, "", "std layout local json check"); + + let test = run_glagol([OsStr::new("test"), project.as_os_str()]); + assert_success_stdout( + test, + EXPECTED_LOCAL_TEST_OUTPUT, + "std layout local json test output", + ); +} + +#[test] +fn standard_json_std_import_project_checks_formats_and_tests() { + let project = + Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples/projects/std-import-json"); + + assert_std_import_json_fixture_uses_repo_std(&project); + + let fmt = run_glagol([ + OsStr::new("fmt"), + OsStr::new("--check"), + project.as_os_str(), + ]); + assert_success("std import json fmt --check", &fmt); + + let check = run_glagol([OsStr::new("check"), project.as_os_str()]); + assert_success_stdout(check, "", "std import json check"); + + let test = run_glagol([OsStr::new("test"), project.as_os_str()]); + assert_success_stdout( + test, + EXPECTED_STD_IMPORT_TEST_OUTPUT, + "std import json test output", + ); +} + +fn assert_local_json_fixture_is_source_authored(project: &Path) { + let json = read(&project.join("src/json.slo")); + let main = read(&project.join("src/main.slo")); + + assert!( + json.starts_with("(module json (export "), + "json.slo must stay an explicit local module export" + ); + assert!( + main.starts_with("(module main)\n\n(import json ("), + "main.slo must stay an explicit local json import" + ); + assert!( + !main.contains("(import std") && !main.contains("(import slovo.std"), + "json fixture must not depend on automatic or package std imports" + ); + assert_json_source_shape(&json, &main, "local json fixture"); + assert!( + !main.contains("std."), + "local json main fixture must use only local imports" + ); +} + +fn assert_std_import_json_fixture_uses_repo_std(project: &Path) { + let std_json = read(&Path::new(env!("CARGO_MANIFEST_DIR")).join("../lib/std/json.slo")); + let main = read(&project.join("src/main.slo")); + + assert!( + !project.join("src/json.slo").exists(), + "std import json fixture must use repo-root std/json.slo, not a local copy" + ); + assert!( + main.starts_with("(module main)\n\n(import std.json ("), + "std import json fixture must use explicit `std.json` import syntax" + ); + assert_json_source_shape(&std_json, &main, "repo std.json fixture"); +} + +fn assert_json_source_shape(json: &str, main: &str, context: &str) { + for runtime_name in STANDARD_JSON_RUNTIME_NAMES { + assert!( + json.contains(runtime_name), + "{} must wrap or compose `{}`", + context, + runtime_name + ); + } + assert_std_only_contains(json, STANDARD_JSON_RUNTIME_NAMES, context); + assert!( + !json.contains("parse") + && !json.contains("token") + && !json.contains("map") + && !json.contains("unicode") + && !json.contains("schema") + && !json.contains("stream") + && !main.contains("parse") + && !main.contains("token") + && !main.contains("map") + && !main.contains("unicode") + && !main.contains("schema") + && !main.contains("stream"), + "{} must not claim deferred JSON parsing or richer data APIs", + context + ); + + for helper in STANDARD_JSON_SOURCE_FACADE_ALPHA { + assert!( + json.contains(&format!("(fn {} ", helper)), + "{} is missing source facade `{}`", + context, + helper + ); + assert!( + main.contains(helper), + "{} main fixture import/use is missing `{}`", + context, + helper + ); + } +} + +fn assert_std_only_contains(source: &str, allowed: &[&str], context: &str) { + let mut remaining = source.to_string(); + for name in allowed { + remaining = remaining.replace(name, ""); + } + assert!( + !remaining.contains("std."), + "{} introduced unexpected compiler-known std names", + context + ); +} + +fn run_glagol(args: I) -> Output +where + I: IntoIterator, + S: AsRef, +{ + Command::new(env!("CARGO_BIN_EXE_glagol")) + .args(args) + .current_dir(Path::new(env!("CARGO_MANIFEST_DIR"))) + .output() + .expect("run glagol") +} + +fn read(path: &Path) -> String { + fs::read_to_string(path).unwrap_or_else(|err| panic!("read `{}`: {}", path.display(), err)) +} + +fn assert_success(context: &str, output: &Output) { + let stdout = String::from_utf8_lossy(&output.stdout); + let stderr = String::from_utf8_lossy(&output.stderr); + + assert!( + output.status.success(), + "{} failed\nstdout:\n{}\nstderr:\n{}", + context, + stdout, + stderr + ); + assert!(stderr.is_empty(), "{} wrote stderr:\n{}", context, stderr); +} + +fn assert_success_stdout(output: Output, expected: &str, context: &str) { + let stdout = String::from_utf8_lossy(&output.stdout); + let stderr = String::from_utf8_lossy(&output.stderr); + + assert!( + output.status.success(), + "{} failed\nstdout:\n{}\nstderr:\n{}", + context, + stdout, + stderr + ); + assert_eq!(stdout, expected, "{} stdout drifted", context); + assert!(stderr.is_empty(), "{} wrote stderr:\n{}", context, stderr); +} diff --git a/docs/POST_BETA_ROADMAP.md b/docs/POST_BETA_ROADMAP.md index dbcd7a3..41a2c2e 100644 --- a/docs/POST_BETA_ROADMAP.md +++ b/docs/POST_BETA_ROADMAP.md @@ -181,6 +181,16 @@ Work: collections exist - add benchmark cases for parsing and formatting +Released in `1.0.0-beta.7`: `lib/std/json.slo` now provides explicit helpers +for compact JSON text construction over strings, booleans, numbers, null, +fields, small arrays, and small objects. `std.json.quote_string` is a +compiler-known runtime helper so JSON string escaping is correct before Slovo +has source-level byte/character scanning and slicing. Matching explicit +std/local source fixtures and a `json-quote-loop` benchmark scaffold are in +place. JSON parsing, recursive JSON values, maps/sets, generic collections, +streaming encoders, schema validation, Unicode normalization, and stable text +encoding policy beyond the current runtime string ABI remain deferred. + Why seventh: networking and CLI tools need data interchange, but a complete JSON library depends on collection work. diff --git a/docs/compiler/RELEASE_NOTES.md b/docs/compiler/RELEASE_NOTES.md index 5764f12..114ba06 100644 --- a/docs/compiler/RELEASE_NOTES.md +++ b/docs/compiler/RELEASE_NOTES.md @@ -12,6 +12,32 @@ integration/readiness release, not the first real beta. No unreleased changes yet. +## 1.0.0-beta.7 + +Release label: `1.0.0-beta.7` + +Release date: 2026-05-22 + +Release state: serialization/data-interchange beta update + +### Summary + +Glagol `1.0.0-beta.7` keeps the `1.0.0-beta` compiler support baseline and +adds the first narrow JSON construction foundation: + +- compiler-known `std.json.quote_string` +- POSIX-hosted runtime support through `__glagol_json_quote_string` +- deterministic interpreter/test-runner behavior for JSON quoting tests +- focused lowering, diagnostics, source-facade, promotion, hosted runtime, and + benchmark-scaffold coverage + +### Explicit Deferrals + +This release does not add JSON parsing, recursive JSON values, maps/sets, +generic collections, streaming encoders, schema validation, Unicode +normalization, stable text encoding policy beyond the current null-terminated +runtime string ABI, or a stable standard-library API freeze. + ## 1.0.0-beta.6 Release label: `1.0.0-beta.6` diff --git a/docs/compiler/ROADMAP.md b/docs/compiler/ROADMAP.md index d63bc1e..2089a5d 100644 --- a/docs/compiler/ROADMAP.md +++ b/docs/compiler/ROADMAP.md @@ -22,15 +22,17 @@ general-purpose beta release. A Glagol feature is done only when it has parser/lowerer support, checker behavior, diagnostics for invalid forms, backend behavior or explicit unsupported diagnostics, and tests. -Current stage: `1.0.0-beta.6`, released on 2026-05-22 as the first post-beta -networking foundation update. It keeps the `1.0.0-beta` language/compiler +Current stage: `1.0.0-beta.7`, released on 2026-05-22 as the first post-beta +serialization/data-interchange foundation update. It keeps the `1.0.0-beta` language/compiler support baseline and includes the `1.0.0-beta.1` tooling hardening release, the `1.0.0-beta.2` runtime/resource foundation release, the `1.0.0-beta.3` standard-library stabilization release, the `1.0.0-beta.4` language-usability diagnostics release, the `1.0.0-beta.5` package/workspace discipline release, and the `1.0.0-beta.6` compiler-known `std.net` loopback TCP runtime family with focused lowering, interpreter, diagnostics, -source-facade, promotion, and hosted smoke coverage. +source-facade, promotion, and hosted smoke coverage, plus the `1.0.0-beta.7` +compiler-known `std.json.quote_string` runtime family with matching +source-facade, test-runner, hosted smoke, and benchmark-scaffold coverage. The final experimental precursor scope is `exp-125`. Its unsigned direct-value flow, parse/format runtime lanes, and matching staged stdlib helper breadth diff --git a/docs/language/RELEASE_NOTES.md b/docs/language/RELEASE_NOTES.md index b7adb27..c4aeaf2 100644 --- a/docs/language/RELEASE_NOTES.md +++ b/docs/language/RELEASE_NOTES.md @@ -8,19 +8,47 @@ Historical `exp-*` releases listed here are experimental maturity milestones. The pushed tag `v2.0.0-beta.1` is historical. It is now documented as an experimental integration/readiness release, not as a beta maturity claim. -The current release is `1.0.0-beta.6`, published on 2026-05-22. It keeps the +The current release is `1.0.0-beta.7`, published on 2026-05-22. It keeps the `1.0.0-beta` language surface, includes the first post-beta tooling/install hardening bundle from `1.0.0-beta.1`, and adds the first runtime/resource foundation bundle from `1.0.0-beta.2` plus the first standard-library stabilization bundle from `1.0.0-beta.3`, the first language-usability diagnostics bundle from `1.0.0-beta.4`, and the first local package/workspace discipline bundle from `1.0.0-beta.5`, plus the first -loopback networking foundation bundle from `1.0.0-beta.6`. +loopback networking foundation bundle from `1.0.0-beta.6`, and the first +serialization/data-interchange foundation bundle from `1.0.0-beta.7`. ## Unreleased No unreleased changes yet. +## 1.0.0-beta.7 + +Release label: `1.0.0-beta.7` + +Release name: Serialization And Data Interchange Bundle + +Release date: 2026-05-22 + +Status: released beta serialization/data-interchange update on the +`1.0.0-beta` language baseline. + +- `lib/std/json.slo` stages an explicit `std.json` source facade for compact + JSON text construction. +- The facade wraps the compiler-known `std.json.quote_string` runtime helper + and composes it with existing `std.string.concat` and `std.num.*_to_string` + helpers for scalar values, fields, small arrays, and small objects. +- `examples/projects/std-import-json/` and + `examples/projects/std-layout-local-json/` document the explicit import and + local source facade shapes. +- `benchmarks/json-quote-loop/` adds a local-machine timing scaffold for JSON + string quoting across Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL. + +This release does not add JSON parsing, recursive JSON values, maps/sets, +generic collections, streaming encoders, schema validation, Unicode +normalization, stable text encoding policy beyond the current null-terminated +runtime string ABI, or a stable standard-library API freeze. + ## 1.0.0-beta.6 Release label: `1.0.0-beta.6` diff --git a/docs/language/ROADMAP.md b/docs/language/ROADMAP.md index fa4127e..1ccaa12 100644 --- a/docs/language/ROADMAP.md +++ b/docs/language/ROADMAP.md @@ -10,16 +10,18 @@ Long-horizon planning lives in release train from the historical `v2.0.0-beta.1` tag toward and beyond the first real general-purpose beta Slovo contract. -Current stage: `1.0.0-beta.6`, released on 2026-05-22 as the first post-beta -networking foundation update. It keeps the `1.0.0-beta` language contract and +Current stage: `1.0.0-beta.7`, released on 2026-05-22 as the first post-beta +serialization/data-interchange foundation update. It keeps the `1.0.0-beta` language contract and includes the `1.0.0-beta.1` tooling hardening release, the `1.0.0-beta.2` runtime/resource foundation release, the `1.0.0-beta.3` standard-library stabilization release, the `1.0.0-beta.4` language-usability diagnostics release, the `1.0.0-beta.5` package/workspace discipline release, and a narrow `std.net` source facade for blocking loopback TCP client/server primitives over -opaque `i32` handles and concrete `result` families. DNS, TLS, UDP, async IO, -non-loopback binding, HTTP frameworks, rich host-error ADTs, stable socket -ABI/layout, and a stable standard-library API freeze remain deferred. +opaque `i32` handles and concrete `result` families, plus a narrow `std.json` +source facade for compact JSON text construction. JSON parsing, recursive JSON +values, maps/sets, DNS, TLS, UDP, async IO, non-loopback binding, HTTP +frameworks, rich host-error ADTs, stable ABI/layout, and a stable +standard-library API freeze remain deferred. The final experimental precursor scope is `exp-125`, defined in `.llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md`. Its diff --git a/docs/language/SPEC-v1.md b/docs/language/SPEC-v1.md index e295925..cf4bc26 100644 --- a/docs/language/SPEC-v1.md +++ b/docs/language/SPEC-v1.md @@ -1076,6 +1076,38 @@ timeouts, buffering policy, HTTP frameworks, platform-specific error codes, rich host-error ADTs, stable runtime helper symbols, stable socket ABI/layout, automatic cleanup, and affine ownership guarantees remain deferred. +### 4.4.5 Post-Beta Serialization Foundation + +Status: released in `1.0.0-beta.7`. + +The `1.0.0-beta.7` serialization foundation stages compact JSON text +construction only. It does not change source syntax. + +The source facade is `lib/std/json.slo`, imported explicitly as `std.json`. +It exposes: + +```text +std.json.quote_string: (string) -> string +std.json.null_value: () -> string +std.json.bool_value: (bool) -> string +std.json.i32_value/u32_value/i64_value/u64_value/f64_value +std.json.field_string/field_bool/field_i32/field_u32/field_i64/field_u64/field_f64/field_null +std.json.array0/array1/array2/array3 +std.json.object0/object1/object2/object3 +``` + +`quote_string` is backed by a compiler-known runtime helper so JSON string +escaping is deterministic even before Slovo has source-visible byte or +character iteration. It returns a complete compact JSON string literal, +including surrounding quotes. The source helpers compose already-encoded JSON +fragments with compact comma/colon separators. + +This release is not a complete JSON or serialization contract. JSON parsing, +recursive JSON values, maps/sets, generic collections, streaming encoders, +schema validation, Unicode normalization, stable text encoding policy beyond +the current null-terminated runtime string ABI, stable runtime helper symbols, +and stable standard-library API guarantees remain deferred. + ## 4.5 v2.0.0-beta.1 Experimental Integration Readiness Status: current experimental Slovo-side release contract, released 2026-05-17. diff --git a/docs/language/STANDARD_RUNTIME.md b/docs/language/STANDARD_RUNTIME.md index 46a5aad..d219631 100644 --- a/docs/language/STANDARD_RUNTIME.md +++ b/docs/language/STANDARD_RUNTIME.md @@ -27,6 +27,11 @@ result-returning, and loopback-only; they do not define DNS, TLS, UDP, async IO, non-loopback binding, HTTP frameworks, stable socket ABI/layout, or rich platform error values. +The `1.0.0-beta.7` serialization/data-interchange foundation release adds +`std.json.quote_string` behind the `std.json` source facade. It provides +deterministic compact JSON string quoting before source-level string scanning, +slicing, maps, or recursive JSON values are available. + The exp-era catalog is closed to names promoted through exp-101. exp-29, exp-30, exp-32, exp-33, and exp-35 through exp-93 add no new standard-runtime operation names. exp-32/exp-39/exp-56/exp-57 `std/math.slo` helpers, @@ -71,6 +76,7 @@ source-level result helper names are the `std.result.*` names cataloged below. | `std.num.f64_to_i64_result` | `(f64) -> (result i64 i32)` | exp-31 | `examples/supported/f64-to-i64-result.slo` | Returns `ok value` only when the `f64` input is finite, exactly integral, and in the signed `i64` range; returns `err 1` for non-finite, fractional, or out-of-range input without trapping. Conservative fixture values avoid pinning every `f64`/`i64` edge. | Uses existing standard-runtime usage recording if present; no schema change. | Unchecked casts, unchecked f64-to-i64, cast syntax, generic `cast_checked`, f32, unsigned/narrower integer families, mixed numeric arithmetic, broad math, stable helper ABI/layout/ownership. | | `std.string.len` | `(string) -> i32` | v1.5 | `examples/supported/standard-runtime.slo` | Returns the existing decoded byte-count length used by legacy `string_len`. | Uses existing standard-runtime usage recording if present; no schema change. | Unicode scalar/grapheme length, slicing, indexing, stable string ABI/layout. | | `std.string.concat` | `(string, string) -> string` | exp-1 | `examples/supported/owned-string-concat.slo` | Returns an immutable runtime-owned string; allocation failure traps as `slovo runtime error: string allocation failed`. | Uses existing standard-runtime usage recording if present; no concat-specific schema field. | Mutable strings, string containers, user-visible allocation/deallocation, stable string ABI/layout. | +| `std.json.quote_string` | `(string) -> string` | `1.0.0-beta.7` | `examples/projects/std-layout-local-json` | Returns a compact JSON string literal for the input text, including surrounding quotes; it escapes quote, backslash, newline, tab, carriage return, backspace, form feed, and other control bytes as JSON escapes. Allocation failure traps as `slovo runtime error: string allocation failed`. | Uses existing standard-runtime usage recording if present; no schema change. | JSON parsing, recursive JSON values, maps/sets, streaming encoders, schema validation, Unicode normalization, embedded NUL support in the current null-terminated string ABI, stable helper ABI/layout/ownership. | | `std.vec.i32.empty` | `() -> (vec i32)` | exp-2 | `examples/supported/vec-i32.slo` | Returns an empty immutable runtime-owned `(vec i32)`. | Uses existing standard-runtime usage recording if present; no vector-specific schema field. | Generic vectors, element families beyond `i32`, `i64`, and `string`, vector mutation, stable vector ABI/layout. | | `std.vec.i32.append` | `((vec i32), i32) -> (vec i32)` | exp-2 | `examples/supported/vec-i32.slo` | Returns a new immutable vector containing the input elements and appended value; allocation failure traps with the exp-2 vector allocation message. | Uses existing standard-runtime usage recording if present; no vector-specific schema field. | Mutation, `push`, capacity APIs, user deallocation, stable vector ABI/layout. | | `std.vec.i32.len` | `((vec i32)) -> i32` | exp-2 | `examples/supported/vec-i32.slo` | Returns vector length as `i32`. | Uses existing standard-runtime usage recording if present; no vector-specific schema field. | Generic length APIs and stable vector ABI/layout. | diff --git a/docs/language/STDLIB_API.md b/docs/language/STDLIB_API.md index ca34d98..d6e4bd4 100644 --- a/docs/language/STDLIB_API.md +++ b/docs/language/STDLIB_API.md @@ -6,15 +6,15 @@ Do not edit this file by hand. ## Stability Tiers - `beta-supported`: exported from `lib/std` and covered by source-search, promotion, or facade gates in the current beta line. -- `experimental`: not used for exported `lib/std` helpers in `1.0.0-beta.6`; future releases may mark new helpers this way before they graduate. +- `experimental`: not used for exported `lib/std` helpers in `1.0.0-beta.7`; future releases may mark new helpers this way before they graduate. - `internal`: helper names that are not exported from their module; they are intentionally omitted from this catalog. The catalog is a beta compatibility aid, not a stable `1.0.0` API freeze. ## Summary -- Modules: 18 -- Exported helpers: 548 +- Modules: 19 +- Exported helpers: 572 - Default tier: `beta-supported` ## Modules @@ -186,6 +186,37 @@ The catalog is a beta compatibility aid, not a stable `1.0.0` API freeze. - `read_stdin_bool_or_false` - `read_stdin_bool_or` +### std.json + +- Path: `lib/std/json.slo` +- Tier: `beta-supported` +- Exported helpers: 24 + +- `quote_string` +- `null_value` +- `bool_value` +- `i32_value` +- `u32_value` +- `i64_value` +- `u64_value` +- `f64_value` +- `field_string` +- `field_bool` +- `field_i32` +- `field_u32` +- `field_i64` +- `field_u64` +- `field_f64` +- `field_null` +- `array0` +- `array1` +- `array2` +- `array3` +- `object0` +- `object1` +- `object2` +- `object3` + ### std.math - Path: `lib/std/math.slo` diff --git a/docs/language/examples/README.md b/docs/language/examples/README.md index ed2b042..49fd10f 100644 --- a/docs/language/examples/README.md +++ b/docs/language/examples/README.md @@ -9,7 +9,10 @@ release notes. The current compiler-supported language baseline is `1.0.0-beta`; `1.0.0-beta.1` adds tooling/install hardening without changing these source-language fixtures. `1.0.0-beta.2` adds beta-scoped runtime/resource foundation APIs. `1.0.0-beta.3` adds the generated stdlib API -catalog and the checked `projects/stdlib-composition/` example. The language +catalog and the checked `projects/stdlib-composition/` example. +`1.0.0-beta.7` adds explicit `projects/std-import-json/` and +`projects/std-layout-local-json/` examples for compact JSON text construction. +The language baseline absorbs the final exp-125 unsigned precursor scope alongside the already promoted project/package, stdlib-source, collection, composite-data, formatter, and diagnostics surface. diff --git a/docs/papers/GLAGOL_COMPILER_MANIFEST.pdf b/docs/papers/GLAGOL_COMPILER_MANIFEST.pdf index 2ac4220..ac00227 100644 Binary files a/docs/papers/GLAGOL_COMPILER_MANIFEST.pdf and b/docs/papers/GLAGOL_COMPILER_MANIFEST.pdf differ diff --git a/docs/papers/GLAGOL_WHITEPAPER.md b/docs/papers/GLAGOL_WHITEPAPER.md index ecc0459..99a1d75 100644 --- a/docs/papers/GLAGOL_WHITEPAPER.md +++ b/docs/papers/GLAGOL_WHITEPAPER.md @@ -5,19 +5,20 @@ Sanjin Gumbarevic
hermeticum_lab@protonmail.com -Publication release: `1.0.0-beta.6` +Publication release: `1.0.0-beta.7` Technical behavior baseline: compiler and language support through `1.0.0-beta`; tooling and install workflow through `1.0.0-beta.1`; runtime/resource foundation through `1.0.0-beta.2`; standard-library stabilization through `1.0.0-beta.3`; language-usability diagnostics through `1.0.0-beta.4`; package/workspace discipline through `1.0.0-beta.5`; -loopback networking foundation through `1.0.0-beta.6` +loopback networking foundation through `1.0.0-beta.6`; +serialization/data-interchange foundation through `1.0.0-beta.7` Date: 2026-05-22 Evidence source: paired local Slovo/Glagol monorepo verification and benchmark -reruns from a local checkout; beta.6 release-gate verification from the public +reruns from a local checkout; beta.7 release-gate verification from the public monorepo Maturity: beta @@ -29,21 +30,23 @@ Slovo. It exists to make the language support boundary inspectable: tokens, S-expression tree, AST, typed AST, LLVM IR, hosted native executable, tests, diagnostics, and release documents should agree. -The current publication release, `1.0.0-beta.6`, keeps the first real +The current publication release, `1.0.0-beta.7`, keeps the first real general-purpose beta toolchain baseline from `1.0.0-beta` and records the first post-beta tooling/install hardening update plus the first runtime/resource foundation update plus the first standard-library stabilization update plus the first language-usability diagnostics update and the first local package/workspace discipline update plus the first loopback -networking foundation update. The beta baseline includes the completed `u32` / -`u64` unsigned compiler and stdlib breadth scope, the narrow `std.net` -loopback TCP runtime family, and the current nine-kernel benchmark suite. This -paper records the current beta implementation surface, the benchmark method and -results, the distinction between Glagol and Lisp-family implementations, the -beta.1 tooling update, the beta.2 runtime/resource foundation, the beta.3 -standard-library stabilization slice, the beta.4 diagnostics usability slice, -the beta.5 package discipline slice, the beta.6 networking foundation slice, -and the compiler path from beta to stable. +networking foundation update plus the first serialization/data-interchange +foundation update. The beta baseline includes the completed `u32` / `u64` +unsigned compiler and stdlib breadth scope, the narrow `std.net` loopback TCP +runtime family, the narrow `std.json.quote_string` runtime family, and the +current ten-scaffold benchmark suite. This paper records the current beta +implementation surface, the benchmark method and results, the distinction +between Glagol and Lisp-family implementations, the beta.1 tooling update, the +beta.2 runtime/resource foundation, the beta.3 standard-library stabilization +slice, the beta.4 diagnostics usability slice, the beta.5 package discipline +slice, the beta.6 networking foundation slice, the beta.7 serialization +foundation slice, and the compiler path from beta to stable. ## 1. Compiler Thesis @@ -123,13 +126,15 @@ At the current technical behavior beta baseline, Glagol supports: `f64`, `bool`, and `string` - compiler-known standard-runtime calls through the promoted catalog plus staged source-authored `std/*.slo` gates +- compact JSON string literal construction through `std.json.quote_string` and + the hosted `__glagol_json_quote_string` runtime helper - scalar C FFI imports - benchmark scaffolds for Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL, with `cold-process` and `hot-loop` timing modes -The current release, `1.0.0-beta.6`, is a beta networking foundation update on -the first release line that may honestly use beta maturity language for this -toolchain. +The current release, `1.0.0-beta.7`, is a beta serialization/data-interchange +foundation update on the first release line that may honestly use beta maturity +language for this toolchain. ## 4. Diagnostics And Support Discipline @@ -218,6 +223,8 @@ Benchmark kernels: accumulation - `vec-string-eq-loop`: runtime-owned string vector indexing plus exact string equality reduced to an `i32` checksum +- `json-quote-loop`: compact JSON string quoting plus quoted-length checksum + accumulation Comparison boundaries: @@ -250,6 +257,10 @@ Comparison boundaries: - `vec-string-eq-loop` keeps the same five-word ASCII corpus and runtime-supplied target as `string-eq-loop`, but routes selection through the promoted runtime-owned `(vec string)` lane instead of fixed arrays. +- `json-quote-loop` keeps one runtime-supplied ASCII string containing a quote + and a backslash and measures compact JSON string quoting plus quoted-length + checksum accumulation. It does not compare JSON parsing, maps, recursive JSON + values, schema validation, or streaming encoders. - Because Rust is timed at `opt-level=3` while Slovo and C are timed through `clang -O2`, the suite is a useful local regression/comparison harness, not a strict same-flags compiler shootout. @@ -266,6 +277,7 @@ python3 benchmarks/array-struct-field-loop/run.py --mode hot-loop --repeats 5 -- python3 benchmarks/enum-struct-payload-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol python3 benchmarks/vec-i32-index-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol python3 benchmarks/vec-string-eq-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol +python3 benchmarks/json-quote-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol ``` Cold-process commands: @@ -280,6 +292,7 @@ python3 benchmarks/array-struct-field-loop/run.py --mode cold-process --repeats python3 benchmarks/enum-struct-payload-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol python3 benchmarks/vec-i32-index-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol python3 benchmarks/vec-string-eq-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol +python3 benchmarks/json-quote-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol ``` ## 7. Benchmark Results @@ -289,8 +302,11 @@ baseline. `1.0.0-beta.1` changes tooling and install workflow, and `1.0.0-beta.2` adds runtime/resource APIs, `1.0.0-beta.3` adds standard-library catalog and composition coverage, `1.0.0-beta.4` improves diagnostics, `1.0.0-beta.5` tightens package/workspace discipline, and -`1.0.0-beta.6` adds a narrow loopback networking foundation. None of these -post-beta slices claims changed benchmark performance. +`1.0.0-beta.6` adds a narrow loopback networking foundation, and +`1.0.0-beta.7` adds a narrow JSON construction foundation. None of these +post-beta slices claims changed benchmark performance. The beta.7 +`json-quote-loop` scaffold is present for local follow-up timing and is not +part of the exp-123 nine-row result table below. The exp-123 publication baseline widened the paired same-machine result set from seven rows to nine by adding two owned-vector kernels: @@ -378,14 +394,15 @@ coverage and compatibility: - package behavior becoming stable before dependency, manifest, and versioning rules are precise -## 9. Path Beyond `1.0.0-beta.6` +## 9. Path Beyond `1.0.0-beta.7` Glagol now implements the first real beta Slovo contract, the first post-beta tooling/install hardening release, the first runtime/resource foundation release, the first standard-library stabilization release, and the -first diagnostics usability release, and the first package/workspace -discipline release, and the first loopback networking foundation release. The -remaining path is from beta to stable. +first diagnostics usability release, the first package/workspace discipline +release, the first loopback networking foundation release, and the first +serialization/data-interchange foundation release. The remaining path is from +beta to stable. Recommended compiler sequence: diff --git a/docs/papers/GLAGOL_WHITEPAPER.pdf b/docs/papers/GLAGOL_WHITEPAPER.pdf index f814dd3..a9a0638 100644 Binary files a/docs/papers/GLAGOL_WHITEPAPER.pdf and b/docs/papers/GLAGOL_WHITEPAPER.pdf differ diff --git a/docs/papers/SLOVO_MANIFEST.pdf b/docs/papers/SLOVO_MANIFEST.pdf index d8e3c9e..f148777 100644 Binary files a/docs/papers/SLOVO_MANIFEST.pdf and b/docs/papers/SLOVO_MANIFEST.pdf differ diff --git a/docs/papers/SLOVO_WHITEPAPER.md b/docs/papers/SLOVO_WHITEPAPER.md index 40b583e..fb5db74 100644 --- a/docs/papers/SLOVO_WHITEPAPER.md +++ b/docs/papers/SLOVO_WHITEPAPER.md @@ -5,19 +5,20 @@ Sanjin Gumbarevic
hermeticum_lab@protonmail.com -Publication release: `1.0.0-beta.6` +Publication release: `1.0.0-beta.7` Technical behavior baseline: language surface through `1.0.0-beta`; tooling and install workflow through `1.0.0-beta.1`; runtime/resource foundation through `1.0.0-beta.2`; standard-library stabilization through `1.0.0-beta.3`; language-usability diagnostics through `1.0.0-beta.4`; package/workspace discipline through `1.0.0-beta.5`; loopback networking foundation through -`1.0.0-beta.6` +`1.0.0-beta.6`; serialization/data-interchange foundation through +`1.0.0-beta.7` Date: 2026-05-22 Evidence source: paired local Slovo/Glagol monorepo verification and benchmark -reruns from a local checkout; beta.6 release-gate verification from the public +reruns from a local checkout; beta.7 release-gate verification from the public monorepo Maturity: beta @@ -32,28 +33,31 @@ explicit types, explicit failure through `option` and `result`, lexical `unsafe`, and native compilation through the Glagol compiler to LLVM IR and hosted executables. -The current publication release, `1.0.0-beta.6`, keeps the first real +The current publication release, `1.0.0-beta.7`, keeps the first real general-purpose beta language baseline from `1.0.0-beta` and records the first post-beta tooling/install hardening update plus the first runtime/resource foundation update, the first standard-library stabilization update, and the first language-usability diagnostics update, plus the first local -package/workspace discipline update, and the first loopback networking -foundation update. The beta baseline includes the completed `u32` / `u64` +package/workspace discipline update, the first loopback networking foundation +update, and the first serialization/data-interchange foundation update. The +beta baseline includes the completed `u32` / `u64` unsigned scope, the staged stdlib breadth that makes ordinary command-line -programs practical, the current narrow `std.net` loopback TCP surface, and the -current nine-kernel benchmark suite. This paper records the current beta +programs practical, the current narrow `std.net` loopback TCP surface, the +current narrow `std.json` text-construction surface, and the current +ten-scaffold benchmark suite. This paper records the current beta technical state, the difference between Slovo and Lisp-family languages, the benchmark methodology, the beta.1 tooling update, the beta.2 runtime/resource foundation, the beta.3 standard-library stabilization slice, the beta.4 diagnostics usability slice, the beta.5 package discipline slice, the beta.6 -networking foundation slice, and the remaining path from beta to stable. +networking foundation slice, the beta.7 serialization foundation slice, and +the remaining path from beta to stable. ## 1. Scope This document is a technical state paper for the current beta baseline. It summarizes the behavior represented by the paired local Slovo and Glagol workspaces, with `1.0.0-beta` as the current language-surface baseline and -`1.0.0-beta.6` as the current publication baseline. +`1.0.0-beta.7` as the current publication baseline. The support rule remains strict: @@ -65,7 +69,7 @@ The support rule remains strict: - partial parser recognition or speculative examples do not count as support Historical `exp-*` releases remain experimental alpha maturity. The current -publication accompanies `1.0.0-beta.6`. +publication accompanies `1.0.0-beta.7`. ## 2. Design Thesis @@ -180,6 +184,7 @@ std/cli.slo std/env.slo std/fs.slo std/io.slo +std/json.slo std/math.slo std/num.slo std/option.slo @@ -295,6 +300,8 @@ Benchmark kernels: accumulation - `vec-string-eq-loop`: runtime-owned string vector indexing plus exact string equality reduced to an `i32` checksum +- `json-quote-loop`: compact JSON string quoting plus quoted-length checksum + accumulation Comparison boundaries: @@ -327,6 +334,10 @@ Comparison boundaries: `(vec string)` lane only: immutable vector creation, checked vector indexing, and exact string equality. It should not widen into regex, normalization, locale handling, or concat-heavy allocation experiments. +- `json-quote-loop` should stay on compact JSON string quoting over a + runtime-supplied ASCII string containing a quote and a backslash. It should + not widen into parsing, recursive JSON values, maps, schema validation, or + streaming encoders. - Because Rust is timed at `opt-level=3` while Slovo and C are timed through `clang -O2`, the suite is a useful local regression/comparison harness, not a strict same-flags compiler shootout. @@ -343,6 +354,7 @@ python3 benchmarks/array-struct-field-loop/run.py --mode hot-loop --repeats 5 -- python3 benchmarks/enum-struct-payload-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol python3 benchmarks/vec-i32-index-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol python3 benchmarks/vec-string-eq-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol +python3 benchmarks/json-quote-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol ``` Cold-process commands: @@ -357,6 +369,7 @@ python3 benchmarks/array-struct-field-loop/run.py --mode cold-process --repeats python3 benchmarks/enum-struct-payload-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol python3 benchmarks/vec-i32-index-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol python3 benchmarks/vec-string-eq-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol +python3 benchmarks/json-quote-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol ``` ## 7. Benchmark Results @@ -366,8 +379,11 @@ baseline. `1.0.0-beta.1` changes tooling and install workflow, and `1.0.0-beta.2` adds runtime/resource APIs, `1.0.0-beta.3` adds standard-library catalog and composition coverage, `1.0.0-beta.4` improves diagnostics, `1.0.0-beta.5` tightens package/workspace discipline, and -`1.0.0-beta.6` adds a narrow loopback networking foundation. None of these -post-beta slices claims changed benchmark performance. +`1.0.0-beta.6` adds a narrow loopback networking foundation, and +`1.0.0-beta.7` adds a narrow JSON construction foundation. None of these +post-beta slices claims changed benchmark performance. The beta.7 +`json-quote-loop` scaffold is present for local follow-up timing and is not +part of the exp-123 nine-row result table below. The exp-123 publication baseline widened the paired same-machine result set from seven rows to nine by adding two owned-vector kernels: @@ -488,7 +504,7 @@ Major remaining gaps before `1.0.0`: - semantic versioning and deprecation policy - a clear separation between stable and experimental features -## 10. Path Beyond `1.0.0-beta.6` +## 10. Path Beyond `1.0.0-beta.7` The beta threshold is now real. The next work should treat `1.0.0-beta` as the language compatibility-governed baseline, `1.0.0-beta.1` as the first @@ -496,7 +512,8 @@ tooling/install hardening point, `1.0.0-beta.2` as the first runtime/resource foundation point, and `1.0.0-beta.3` as the first standard-library stabilization point, and `1.0.0-beta.4` as the first diagnostics usability point, and `1.0.0-beta.5` as the first package/workspace discipline point, -and `1.0.0-beta.6` as the first loopback networking foundation point, +and `1.0.0-beta.6` as the first loopback networking foundation point, and +`1.0.0-beta.7` as the first serialization/data-interchange foundation point, then move deliberately toward stable general-purpose status. Recommended sequence: diff --git a/docs/papers/SLOVO_WHITEPAPER.pdf b/docs/papers/SLOVO_WHITEPAPER.pdf index 124adae..9d287ce 100644 Binary files a/docs/papers/SLOVO_WHITEPAPER.pdf and b/docs/papers/SLOVO_WHITEPAPER.pdf differ diff --git a/examples/projects/std-import-json/slovo.toml b/examples/projects/std-import-json/slovo.toml new file mode 100644 index 0000000..4f3ce1c --- /dev/null +++ b/examples/projects/std-import-json/slovo.toml @@ -0,0 +1,4 @@ +[project] +name = "std-import-json" +source_root = "src" +entry = "main" diff --git a/examples/projects/std-import-json/src/main.slo b/examples/projects/std-import-json/src/main.slo new file mode 100644 index 0000000..f2e0276 --- /dev/null +++ b/examples/projects/std-import-json/src/main.slo @@ -0,0 +1,92 @@ +(module main) + +(import std.json (quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3)) + +(fn imported_json_quote_escapes () -> bool + (if (= (quote_string "slovo") "\"slovo\"") + (if (= (quote_string "slo\"vo") "\"slo\\\"vo\"") + (if (= (quote_string "slo\\vo") "\"slo\\\\vo\"") + (= (quote_string "line\nnext") "\"line\\nnext\"") + false) + false) + false)) + +(fn imported_json_scalar_values () -> bool + (if (= (null_value) "null") + (if (= (bool_value true) "true") + (if (= (bool_value false) "false") + (if (= (i32_value -7) "-7") + (if (= (u32_value 7u32) "7") + (if (= (i64_value 8i64) "8") + (if (= (u64_value 9u64) "9") + (= (f64_value 1.5) "1.5") + false) + false) + false) + false) + false) + false) + false)) + +(fn imported_json_fields () -> bool + (if (= (field_string "name" "slo\"vo") "\"name\":\"slo\\\"vo\"") + (if (= (field_bool "ok" true) "\"ok\":true") + (if (= (field_i32 "count" 3) "\"count\":3") + (if (= (field_u32 "u32" 4u32) "\"u32\":4") + (if (= (field_i64 "i64" 5i64) "\"i64\":5") + (if (= (field_u64 "u64" 6u64) "\"u64\":6") + (if (= (field_f64 "ratio" 2.5) "\"ratio\":2.5") + (= (field_null "none") "\"none\":null") + false) + false) + false) + false) + false) + false) + false)) + +(fn imported_json_arrays_objects () -> bool + (if (= (array0) "[]") + (if (= (array1 (quote_string "a")) "[\"a\"]") + (if (= (array2 (quote_string "a") (i32_value 7)) "[\"a\",7]") + (if (= (array3 (quote_string "a") (i32_value 7) (bool_value true)) "[\"a\",7,true]") + (if (= (object0) "{}") + (if (= (object1 (field_string "name" "slovo")) "{\"name\":\"slovo\"}") + (if (= (object2 (field_string "name" "slovo") (field_i32 "count" 3)) "{\"name\":\"slovo\",\"count\":3}") + (= (object3 (field_string "name" "slovo") (field_i32 "count" 3) (field_bool "ok" true)) "{\"name\":\"slovo\",\"count\":3,\"ok\":true}") + false) + false) + false) + false) + false) + false) + false)) + +(fn imported_json_all () -> bool + (if (imported_json_quote_escapes) + (if (imported_json_scalar_values) + (if (imported_json_fields) + (imported_json_arrays_objects) + false) + false) + false)) + +(fn main () -> i32 + (if (imported_json_all) + 42 + 1)) + +(test "explicit std json quote escapes facade" + (imported_json_quote_escapes)) + +(test "explicit std json scalar values facade" + (imported_json_scalar_values)) + +(test "explicit std json fields facade" + (imported_json_fields)) + +(test "explicit std json arrays objects facade" + (imported_json_arrays_objects)) + +(test "explicit std json facade all" + (= (main) 42)) diff --git a/examples/projects/std-layout-local-json/slovo.toml b/examples/projects/std-layout-local-json/slovo.toml new file mode 100644 index 0000000..6155418 --- /dev/null +++ b/examples/projects/std-layout-local-json/slovo.toml @@ -0,0 +1,4 @@ +[project] +name = "std-layout-local-json" +source_root = "src" +entry = "main" diff --git a/examples/projects/std-layout-local-json/src/json.slo b/examples/projects/std-layout-local-json/src/json.slo new file mode 100644 index 0000000..1933029 --- /dev/null +++ b/examples/projects/std-layout-local-json/src/json.slo @@ -0,0 +1,78 @@ +(module json (export quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3)) + +(fn quote_string ((value string)) -> string + (std.json.quote_string value)) + +(fn null_value () -> string + "null") + +(fn bool_value ((value bool)) -> string + (if value + "true" + "false")) + +(fn i32_value ((value i32)) -> string + (std.num.i32_to_string value)) + +(fn u32_value ((value u32)) -> string + (std.num.u32_to_string value)) + +(fn i64_value ((value i64)) -> string + (std.num.i64_to_string value)) + +(fn u64_value ((value u64)) -> string + (std.num.u64_to_string value)) + +(fn f64_value ((value f64)) -> string + (std.num.f64_to_string value)) + +(fn field_fragment ((name string) (encoded_value string)) -> string + (std.string.concat (std.string.concat (quote_string name) ":") encoded_value)) + +(fn field_string ((name string) (value string)) -> string + (field_fragment name (quote_string value))) + +(fn field_bool ((name string) (value bool)) -> string + (field_fragment name (bool_value value))) + +(fn field_i32 ((name string) (value i32)) -> string + (field_fragment name (i32_value value))) + +(fn field_u32 ((name string) (value u32)) -> string + (field_fragment name (u32_value value))) + +(fn field_i64 ((name string) (value i64)) -> string + (field_fragment name (i64_value value))) + +(fn field_u64 ((name string) (value u64)) -> string + (field_fragment name (u64_value value))) + +(fn field_f64 ((name string) (value f64)) -> string + (field_fragment name (f64_value value))) + +(fn field_null ((name string)) -> string + (field_fragment name (null_value))) + +(fn array0 () -> string + "[]") + +(fn array1 ((first string)) -> string + (std.string.concat (std.string.concat "[" first) "]")) + +(fn array2 ((first string) (second string)) -> string + (std.string.concat (std.string.concat (std.string.concat (std.string.concat "[" first) ",") second) "]")) + +(fn array3 ((first string) (second string) (third string)) -> string + (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat "[" first) ",") second) ",") third) "]")) + +(fn object0 () -> string + "{}") + +(fn object1 ((first string)) -> string + (std.string.concat (std.string.concat "{" first) "}")) + +(fn object2 ((first string) (second string)) -> string + (std.string.concat (std.string.concat (std.string.concat (std.string.concat "{" first) ",") second) "}")) + +(fn object3 ((first string) (second string) (third string)) -> string + (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat "{" first) ",") second) ",") third) "}")) diff --git a/examples/projects/std-layout-local-json/src/main.slo b/examples/projects/std-layout-local-json/src/main.slo new file mode 100644 index 0000000..52601d7 --- /dev/null +++ b/examples/projects/std-layout-local-json/src/main.slo @@ -0,0 +1,92 @@ +(module main) + +(import json (quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3)) + +(fn imported_json_quote_escapes () -> bool + (if (= (quote_string "slovo") "\"slovo\"") + (if (= (quote_string "slo\"vo") "\"slo\\\"vo\"") + (if (= (quote_string "slo\\vo") "\"slo\\\\vo\"") + (= (quote_string "line\nnext") "\"line\\nnext\"") + false) + false) + false)) + +(fn imported_json_scalar_values () -> bool + (if (= (null_value) "null") + (if (= (bool_value true) "true") + (if (= (bool_value false) "false") + (if (= (i32_value -7) "-7") + (if (= (u32_value 7u32) "7") + (if (= (i64_value 8i64) "8") + (if (= (u64_value 9u64) "9") + (= (f64_value 1.5) "1.5") + false) + false) + false) + false) + false) + false) + false)) + +(fn imported_json_fields () -> bool + (if (= (field_string "name" "slo\"vo") "\"name\":\"slo\\\"vo\"") + (if (= (field_bool "ok" true) "\"ok\":true") + (if (= (field_i32 "count" 3) "\"count\":3") + (if (= (field_u32 "u32" 4u32) "\"u32\":4") + (if (= (field_i64 "i64" 5i64) "\"i64\":5") + (if (= (field_u64 "u64" 6u64) "\"u64\":6") + (if (= (field_f64 "ratio" 2.5) "\"ratio\":2.5") + (= (field_null "none") "\"none\":null") + false) + false) + false) + false) + false) + false) + false)) + +(fn imported_json_arrays_objects () -> bool + (if (= (array0) "[]") + (if (= (array1 (quote_string "a")) "[\"a\"]") + (if (= (array2 (quote_string "a") (i32_value 7)) "[\"a\",7]") + (if (= (array3 (quote_string "a") (i32_value 7) (bool_value true)) "[\"a\",7,true]") + (if (= (object0) "{}") + (if (= (object1 (field_string "name" "slovo")) "{\"name\":\"slovo\"}") + (if (= (object2 (field_string "name" "slovo") (field_i32 "count" 3)) "{\"name\":\"slovo\",\"count\":3}") + (= (object3 (field_string "name" "slovo") (field_i32 "count" 3) (field_bool "ok" true)) "{\"name\":\"slovo\",\"count\":3,\"ok\":true}") + false) + false) + false) + false) + false) + false) + false)) + +(fn imported_json_all () -> bool + (if (imported_json_quote_escapes) + (if (imported_json_scalar_values) + (if (imported_json_fields) + (imported_json_arrays_objects) + false) + false) + false)) + +(fn main () -> i32 + (if (imported_json_all) + 42 + 1)) + +(test "explicit local json quote escapes facade" + (imported_json_quote_escapes)) + +(test "explicit local json scalar values facade" + (imported_json_scalar_values)) + +(test "explicit local json fields facade" + (imported_json_fields)) + +(test "explicit local json arrays objects facade" + (imported_json_arrays_objects)) + +(test "explicit local json facade all" + (= (main) 42)) diff --git a/lib/std/README.md b/lib/std/README.md index d081c85..cbce03f 100644 --- a/lib/std/README.md +++ b/lib/std/README.md @@ -33,7 +33,9 @@ through released `exp-108`, including the current concrete `std/vec_string.slo`, `std/vec_f64.slo`, and `std/vec_bool.slo` prefix/suffix helper scopes; `1.0.0-beta.6` networking foundation work releases `std/net.slo` as an experimental loopback TCP facade over matching -compiler-known runtime calls. +compiler-known runtime calls; `1.0.0-beta.7` serialization work releases +`std/json.slo` as an experimental JSON text-construction facade over +`std.json.quote_string` and existing string/number helpers. This directory is the source home for staged standard library modules and examples. exp-44 lets project-mode source explicitly import `std/math.slo` as @@ -92,6 +94,11 @@ loopback TCP facade over `std.net.tcp_connect_loopback_result`, `std.net.tcp_write_text_result`, and `std.net.tcp_close_result`, while keeping socket handles beta-scoped opaque `i32` values and leaving DNS, TLS, async, UDP, non-loopback binding, and stable ABI/layout deferred; +`1.0.0-beta.7` releases `std/json.slo` as an experimental compact JSON +text-construction facade over `std.json.quote_string`, `std.string.concat`, +and the current `std.num.*_to_string` helpers, while leaving JSON parsing, +recursive JSON values, maps/sets, streaming encoders, schema validation, +Unicode normalization, and stable text encoding policy deferred; exp-76 extends project-mode source search to `std/vec_i32.slo`, a concrete source-authored collection facade over the current promoted `std.vec.i32` runtime family; exp-77 extends that facade with concrete option-returning @@ -136,13 +143,13 @@ For exp-44, exp-45, exp-47, exp-48, exp-49, exp-52, exp-53, exp-76, exp-94, exp-96, exp-97, exp-98, exp-99, exp-103, exp-104, exp-105, exp-107, and exp-108, `std/math.slo`, `std/result.slo`, `std/option.slo`, `std/time.slo`, `std/random.slo`, `std/env.slo`, -`std/fs.slo`, `std/net.slo`, `std/string.slo`, `std/num.slo`, +`std/fs.slo`, `std/net.slo`, `std/json.slo`, `std/string.slo`, `std/num.slo`, `std/io.slo`, `std/process.slo`, `std/cli.slo`, `std/vec_i32.slo`, `std/vec_f64.slo`, `std/vec_i64.slo`, and `std/vec_string.slo` carry explicit export lists. Glagol may address them externally as `std.math`, `std.result`, `std.option`, `std.time`, `std.random`, `std.env`, `std.fs`, `std.string`, -`std.net`, `std.num`, `std.io`, `std.process`, `std.cli`, `std.vec_i32`, +`std.net`, `std.json`, `std.num`, `std.io`, `std.process`, `std.cli`, `std.vec_i32`, `std.vec_f64`, `std.vec_bool`, `std.vec_i64`, and `std.vec_string`. The file layout is the contract: @@ -164,6 +171,7 @@ The file layout is the contract: - `std/env.slo` - `std/fs.slo` - `std/net.slo` +- `std/json.slo` This follows a Zig-like standard-library facade discipline in a Slovo-sized form: flat `std/*.slo` facade files are the staged source surface now, and a @@ -278,6 +286,12 @@ close result calls and adds only `tcp_write_text_ok` and `tcp_close_ok` source helpers. It is not a general networking module: DNS, TLS, async IO, UDP, non-loopback binding, socket options, rich host errors, and stable handle ABI remain deferred. +`std/json.slo` is the beta.7 serialization/data-interchange source facade. It +wraps `std.json.quote_string` and composes compact JSON scalar, field, small +array, and small object text from existing string and number helpers. It is +not a JSON parser and does not define recursive JSON values, maps/sets, +streaming encoders, schema validation, Unicode normalization, or stable text +encoding policy beyond the current runtime string ABI. `std/process.slo` includes the exp-52 narrow source wrappers over already released process argument runtime calls and a source-authored `has_arg` predicate. exp-61 adds `arg_or` and `arg_or_empty` as ordinary source diff --git a/lib/std/json.slo b/lib/std/json.slo new file mode 100644 index 0000000..1933029 --- /dev/null +++ b/lib/std/json.slo @@ -0,0 +1,78 @@ +(module json (export quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3)) + +(fn quote_string ((value string)) -> string + (std.json.quote_string value)) + +(fn null_value () -> string + "null") + +(fn bool_value ((value bool)) -> string + (if value + "true" + "false")) + +(fn i32_value ((value i32)) -> string + (std.num.i32_to_string value)) + +(fn u32_value ((value u32)) -> string + (std.num.u32_to_string value)) + +(fn i64_value ((value i64)) -> string + (std.num.i64_to_string value)) + +(fn u64_value ((value u64)) -> string + (std.num.u64_to_string value)) + +(fn f64_value ((value f64)) -> string + (std.num.f64_to_string value)) + +(fn field_fragment ((name string) (encoded_value string)) -> string + (std.string.concat (std.string.concat (quote_string name) ":") encoded_value)) + +(fn field_string ((name string) (value string)) -> string + (field_fragment name (quote_string value))) + +(fn field_bool ((name string) (value bool)) -> string + (field_fragment name (bool_value value))) + +(fn field_i32 ((name string) (value i32)) -> string + (field_fragment name (i32_value value))) + +(fn field_u32 ((name string) (value u32)) -> string + (field_fragment name (u32_value value))) + +(fn field_i64 ((name string) (value i64)) -> string + (field_fragment name (i64_value value))) + +(fn field_u64 ((name string) (value u64)) -> string + (field_fragment name (u64_value value))) + +(fn field_f64 ((name string) (value f64)) -> string + (field_fragment name (f64_value value))) + +(fn field_null ((name string)) -> string + (field_fragment name (null_value))) + +(fn array0 () -> string + "[]") + +(fn array1 ((first string)) -> string + (std.string.concat (std.string.concat "[" first) "]")) + +(fn array2 ((first string) (second string)) -> string + (std.string.concat (std.string.concat (std.string.concat (std.string.concat "[" first) ",") second) "]")) + +(fn array3 ((first string) (second string) (third string)) -> string + (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat "[" first) ",") second) ",") third) "]")) + +(fn object0 () -> string + "{}") + +(fn object1 ((first string)) -> string + (std.string.concat (std.string.concat "{" first) "}")) + +(fn object2 ((first string) (second string)) -> string + (std.string.concat (std.string.concat (std.string.concat (std.string.concat "{" first) ",") second) "}")) + +(fn object3 ((first string) (second string) (third string)) -> string + (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat "{" first) ",") second) ",") third) "}")) diff --git a/runtime/runtime.c b/runtime/runtime.c index 29c8caf..6591f5f 100644 --- a/runtime/runtime.c +++ b/runtime/runtime.c @@ -726,6 +726,105 @@ char *__glagol_string_concat(const char *left, const char *right) { return value; } +static char __glagol_json_hex_digit(unsigned char value) { + return value < 10u ? (char)('0' + value) : (char)('A' + (value - 10u)); +} + +static void __glagol_json_add_size(size_t *total, size_t amount) { + if (*total > SIZE_MAX - amount) { + __glagol_allocation_trap(); + } + *total += amount; +} + +char *__glagol_json_quote_string(const char *text) { + if (text == NULL) { + text = ""; + } + + size_t escaped_len = 2u; + const unsigned char *cursor = (const unsigned char *)text; + while (*cursor != '\0') { + switch (*cursor) { + case '"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + __glagol_json_add_size(&escaped_len, 2u); + break; + default: + __glagol_json_add_size(&escaped_len, *cursor < 0x20u ? 6u : 1u); + break; + } + cursor++; + } + + if (escaped_len == SIZE_MAX) { + __glagol_allocation_trap(); + } + + char *value = malloc(escaped_len + 1u); + if (value == NULL) { + __glagol_allocation_trap(); + } + + char *out = value; + *out++ = '"'; + cursor = (const unsigned char *)text; + while (*cursor != '\0') { + unsigned char ch = *cursor; + switch (ch) { + case '"': + *out++ = '\\'; + *out++ = '"'; + break; + case '\\': + *out++ = '\\'; + *out++ = '\\'; + break; + case '\b': + *out++ = '\\'; + *out++ = 'b'; + break; + case '\f': + *out++ = '\\'; + *out++ = 'f'; + break; + case '\n': + *out++ = '\\'; + *out++ = 'n'; + break; + case '\r': + *out++ = '\\'; + *out++ = 'r'; + break; + case '\t': + *out++ = '\\'; + *out++ = 't'; + break; + default: + if (ch < 0x20u) { + *out++ = '\\'; + *out++ = 'u'; + *out++ = '0'; + *out++ = '0'; + *out++ = __glagol_json_hex_digit((unsigned char)(ch >> 4u)); + *out++ = __glagol_json_hex_digit((unsigned char)(ch & 0x0Fu)); + } else { + *out++ = (char)ch; + } + break; + } + cursor++; + } + *out++ = '"'; + *out = '\0'; + return value; +} + static char *__glagol_num_u64_to_string_impl(uint64_t magnitude, bool negative) { char reversed[20]; size_t digit_count = 0; diff --git a/tests/std-abi-layout-unsupported.diag b/tests/std-abi-layout-unsupported.diag index e008d94..d21f4c3 100644 --- a/tests/std-abi-layout-unsupported.diag +++ b/tests/std-abi-layout-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 52) (range 5 4 5 18) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.abi.layout") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-async-spawn-unsupported.diag b/tests/std-async-spawn-unsupported.diag index c185b18..edecb74 100644 --- a/tests/std-async-spawn-unsupported.diag +++ b/tests/std-async-spawn-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 53) (range 5 4 5 19) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.async.spawn") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-fs-list-dir-unsupported.diag b/tests/std-fs-list-dir-unsupported.diag index 8df7b9f..5c3437d 100644 --- a/tests/std-fs-list-dir-unsupported.diag +++ b/tests/std-fs-list-dir-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 53) (range 5 4 5 19) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.fs.list_dir") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-fs-read-binary-unsupported-alias.diag b/tests/std-fs-read-binary-unsupported-alias.diag index 7e5818b..bfde428 100644 --- a/tests/std-fs-read-binary-unsupported-alias.diag +++ b/tests/std-fs-read-binary-unsupported-alias.diag @@ -9,7 +9,7 @@ (bytes 41 59) (range 5 4 5 22) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.fs.read_binary") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-io-prompt-unsupported.diag b/tests/std-io-prompt-unsupported.diag index a33ddeb..8ab9a3b 100644 --- a/tests/std-io-prompt-unsupported.diag +++ b/tests/std-io-prompt-unsupported.diag @@ -9,7 +9,7 @@ (bytes 41 54) (range 5 4 5 17) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.prompt") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-io-read-line-unsupported.diag b/tests/std-io-read-line-unsupported.diag index 602c913..8317d92 100644 --- a/tests/std-io-read-line-unsupported.diag +++ b/tests/std-io-read-line-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 54) (range 5 4 5 20) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.read_line") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-io-read-stdin-async-unsupported.diag b/tests/std-io-read-stdin-async-unsupported.diag index 57d1de6..1101901 100644 --- a/tests/std-io-read-stdin-async-unsupported.diag +++ b/tests/std-io-read-stdin-async-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 61) (range 5 4 5 27) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.read_stdin_async") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-io-read-stdin-binary-unsupported.diag b/tests/std-io-read-stdin-binary-unsupported.diag index 000e2a4..7ef4893 100644 --- a/tests/std-io-read-stdin-binary-unsupported.diag +++ b/tests/std-io-read-stdin-binary-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 62) (range 5 4 5 28) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.read_stdin_binary") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-io-read-stdin-bytes-unsupported.diag b/tests/std-io-read-stdin-bytes-unsupported.diag index 6473041..11397ea 100644 --- a/tests/std-io-read-stdin-bytes-unsupported.diag +++ b/tests/std-io-read-stdin-bytes-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 61) (range 5 4 5 27) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.read_stdin_bytes") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-io-read-stdin-unsupported.diag b/tests/std-io-read-stdin-unsupported.diag index ff67225..9a5bf6a 100644 --- a/tests/std-io-read-stdin-unsupported.diag +++ b/tests/std-io-read-stdin-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 55) (range 5 4 5 21) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.read_stdin") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-io-stdin-encoding-unsupported.diag b/tests/std-io-stdin-encoding-unsupported.diag index cbe702f..987a8ca 100644 --- a/tests/std-io-stdin-encoding-unsupported.diag +++ b/tests/std-io-stdin-encoding-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 59) (range 5 4 5 25) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.stdin_encoding") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-io-stdin-lines-unsupported.diag b/tests/std-io-stdin-lines-unsupported.diag index 90f0bf8..ee5ddeb 100644 --- a/tests/std-io-stdin-lines-unsupported.diag +++ b/tests/std-io-stdin-lines-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 56) (range 5 4 5 22) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.stdin_lines") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-io-stdin-stream-unsupported.diag b/tests/std-io-stdin-stream-unsupported.diag index ba699f1..7d683c9 100644 --- a/tests/std-io-stdin-stream-unsupported.diag +++ b/tests/std-io-stdin-stream-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 57) (range 5 4 5 23) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.stdin_stream") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-net-connect-unsupported.diag b/tests/std-net-connect-unsupported.diag index 65f08fa..9a8fb1c 100644 --- a/tests/std-net-connect-unsupported.diag +++ b/tests/std-net-connect-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 53) (range 5 4 5 19) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.net.connect") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-num-cast-checked-unsupported.diag b/tests/std-num-cast-checked-unsupported.diag index 731cb9b..19bf6da 100644 --- a/tests/std-num-cast-checked-unsupported.diag +++ b/tests/std-num-cast-checked-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 58) (range 5 4 5 24) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.num.cast_checked") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-num-cast-unsupported.diag b/tests/std-num-cast-unsupported.diag index 4668013..92031ca 100644 --- a/tests/std-num-cast-unsupported.diag +++ b/tests/std-num-cast-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 50) (range 5 4 5 16) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.num.cast") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-num-f64-to-i32-unsupported.diag b/tests/std-num-f64-to-i32-unsupported.diag index f89169e..e267d38 100644 --- a/tests/std-num-f64-to-i32-unsupported.diag +++ b/tests/std-num-f64-to-i32-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 56) (range 5 4 5 22) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.num.f64_to_i32") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-num-f64-to-i64-unsupported.diag b/tests/std-num-f64-to-i64-unsupported.diag index c6392aa..14ec6ce 100644 --- a/tests/std-num-f64-to-i64-unsupported.diag +++ b/tests/std-num-f64-to-i64-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 56) (range 5 4 5 22) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.num.f64_to_i64") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-num-i32-to-i64-result-unsupported.diag b/tests/std-num-i32-to-i64-result-unsupported.diag index 566cf9c..c87c66b 100644 --- a/tests/std-num-i32-to-i64-result-unsupported.diag +++ b/tests/std-num-i32-to-i64-result-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 63) (range 5 4 5 29) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.num.i32_to_i64_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-num-i64-to-i32-unsupported.diag b/tests/std-num-i64-to-i32-unsupported.diag index bdef7c8..083566d 100644 --- a/tests/std-num-i64-to-i32-unsupported.diag +++ b/tests/std-num-i64-to-i32-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 56) (range 5 4 5 22) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.num.i64_to_i32") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-num-to-string-unsupported.diag b/tests/std-num-to-string-unsupported.diag index c680bc6..97dcec6 100644 --- a/tests/std-num-to-string-unsupported.diag +++ b/tests/std-num-to-string-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 55) (range 5 4 5 21) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.num.to_string") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-package-load-unsupported.diag b/tests/std-package-load-unsupported.diag index a65550a..49e1b84 100644 --- a/tests/std-package-load-unsupported.diag +++ b/tests/std-package-load-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 54) (range 5 4 5 20) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.package.load") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-platform-os-unsupported.diag b/tests/std-platform-os-unsupported.diag index 6ab9639..ffa894f 100644 --- a/tests/std-platform-os-unsupported.diag +++ b/tests/std-platform-os-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 53) (range 5 4 5 19) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.platform.os") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-random-bytes-unsupported.diag b/tests/std-random-bytes-unsupported.diag index 61c21c2..2e1c052 100644 --- a/tests/std-random-bytes-unsupported.diag +++ b/tests/std-random-bytes-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 54) (range 5 4 5 20) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.random.bytes") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-random-crypto-i32-unsupported.diag b/tests/std-random-crypto-i32-unsupported.diag index bae745a..8dc9e22 100644 --- a/tests/std-random-crypto-i32-unsupported.diag +++ b/tests/std-random-crypto-i32-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 59) (range 5 4 5 25) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.random.crypto_i32") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-random-float-unsupported.diag b/tests/std-random-float-unsupported.diag index 9366cd3..c733d94 100644 --- a/tests/std-random-float-unsupported.diag +++ b/tests/std-random-float-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 54) (range 5 4 5 20) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.random.float") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-random-range-unsupported.diag b/tests/std-random-range-unsupported.diag index dd6b786..f03cf2a 100644 --- a/tests/std-random-range-unsupported.diag +++ b/tests/std-random-range-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 54) (range 5 4 5 20) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.random.range") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-random-seed-unsupported.diag b/tests/std-random-seed-unsupported.diag index a2f9103..aa2f5a7 100644 --- a/tests/std-random-seed-unsupported.diag +++ b/tests/std-random-seed-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 53) (range 5 4 5 19) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.random.seed") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-random-shuffle-unsupported.diag b/tests/std-random-shuffle-unsupported.diag index 0097280..3198efb 100644 --- a/tests/std-random-shuffle-unsupported.diag +++ b/tests/std-random-shuffle-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 56) (range 5 4 5 22) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.random.shuffle") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-random-string-unsupported.diag b/tests/std-random-string-unsupported.diag index 8709dfd..b112a3b 100644 --- a/tests/std-random-string-unsupported.diag +++ b/tests/std-random-string-unsupported.diag @@ -9,7 +9,7 @@ (bytes 41 58) (range 5 4 5 21) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.random.string") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-random-uuid-unsupported.diag b/tests/std-random-uuid-unsupported.diag index 3e0e3c0..daac9d3 100644 --- a/tests/std-random-uuid-unsupported.diag +++ b/tests/std-random-uuid-unsupported.diag @@ -9,7 +9,7 @@ (bytes 41 56) (range 5 4 5 19) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.random.uuid") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-result-map-unsupported.diag b/tests/std-result-map-unsupported.diag index ec04aab..1682179 100644 --- a/tests/std-result-map-unsupported.diag +++ b/tests/std-result-map-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 52) (range 5 4 5 18) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.result.map") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-from-i64-unsupported.diag b/tests/std-string-from-i64-unsupported.diag index a4724f8..d74c685 100644 --- a/tests/std-string-from-i64-unsupported.diag +++ b/tests/std-string-from-i64-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 57) (range 5 4 5 23) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.from_i64") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-index-unsupported.diag b/tests/std-string-index-unsupported.diag index 3652e37..6e20707 100644 --- a/tests/std-string-index-unsupported.diag +++ b/tests/std-string-index-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 54) (range 5 4 5 20) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.index") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-bool-unsupported.diag b/tests/std-string-parse-bool-unsupported.diag index 0c6e03c..cc516c9 100644 --- a/tests/std-string-parse-bool-unsupported.diag +++ b/tests/std-string-parse-bool-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 59) (range 5 4 5 25) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_bool") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-bytes-unsupported.diag b/tests/std-string-parse-bytes-unsupported.diag index 41bc66c..858017f 100644 --- a/tests/std-string-parse-bytes-unsupported.diag +++ b/tests/std-string-parse-bytes-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 67) (range 5 4 5 33) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_bytes_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-f64-unsupported.diag b/tests/std-string-parse-f64-unsupported.diag index 0c430a4..5fec889 100644 --- a/tests/std-string-parse-f64-unsupported.diag +++ b/tests/std-string-parse-f64-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 58) (range 5 4 5 24) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_f64") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-generic-unsupported.diag b/tests/std-string-parse-generic-unsupported.diag index 62c9f94..5cf6f75 100644 --- a/tests/std-string-parse-generic-unsupported.diag +++ b/tests/std-string-parse-generic-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 61) (range 5 4 5 27) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-base-prefix-unsupported.diag b/tests/std-string-parse-i32-base-prefix-unsupported.diag index 2022ff2..303404a 100644 --- a/tests/std-string-parse-i32-base-prefix-unsupported.diag +++ b/tests/std-string-parse-i32-base-prefix-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 77) (range 5 4 5 43) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_base_prefix_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-binary-unsupported.diag b/tests/std-string-parse-i32-binary-unsupported.diag index 985ee8a..27fc05e 100644 --- a/tests/std-string-parse-i32-binary-unsupported.diag +++ b/tests/std-string-parse-i32-binary-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 72) (range 5 4 5 38) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_binary_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-code-unsupported.diag b/tests/std-string-parse-i32-code-unsupported.diag index edc1718..730d332 100644 --- a/tests/std-string-parse-i32-code-unsupported.diag +++ b/tests/std-string-parse-i32-code-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 70) (range 5 4 5 36) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_code_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-error-adt-unsupported.diag b/tests/std-string-parse-i32-error-adt-unsupported.diag index e5b8672..3155856 100644 --- a/tests/std-string-parse-i32-error-adt-unsupported.diag +++ b/tests/std-string-parse-i32-error-adt-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 71) (range 5 4 5 37) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_error_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-hex-unsupported.diag b/tests/std-string-parse-i32-hex-unsupported.diag index 9973dec..77366da 100644 --- a/tests/std-string-parse-i32-hex-unsupported.diag +++ b/tests/std-string-parse-i32-hex-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 69) (range 5 4 5 35) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_hex_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-locale-unsupported.diag b/tests/std-string-parse-i32-locale-unsupported.diag index a4b56d7..5f3ec2c 100644 --- a/tests/std-string-parse-i32-locale-unsupported.diag +++ b/tests/std-string-parse-i32-locale-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 72) (range 5 4 5 38) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_locale_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-message-unsupported.diag b/tests/std-string-parse-i32-message-unsupported.diag index 3526593..52a8130 100644 --- a/tests/std-string-parse-i32-message-unsupported.diag +++ b/tests/std-string-parse-i32-message-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 73) (range 5 4 5 39) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_message_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-octal-unsupported.diag b/tests/std-string-parse-i32-octal-unsupported.diag index 0f4ec64..1f48679 100644 --- a/tests/std-string-parse-i32-octal-unsupported.diag +++ b/tests/std-string-parse-i32-octal-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 71) (range 5 4 5 37) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_octal_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-plus-unsupported.diag b/tests/std-string-parse-i32-plus-unsupported.diag index d5d0120..c824755 100644 --- a/tests/std-string-parse-i32-plus-unsupported.diag +++ b/tests/std-string-parse-i32-plus-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 70) (range 5 4 5 36) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_plus_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-radix-unsupported.diag b/tests/std-string-parse-i32-radix-unsupported.diag index 824a934..92babef 100644 --- a/tests/std-string-parse-i32-radix-unsupported.diag +++ b/tests/std-string-parse-i32-radix-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 71) (range 5 4 5 37) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_radix_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-trim-unsupported.diag b/tests/std-string-parse-i32-trim-unsupported.diag index c386b85..db580e4 100644 --- a/tests/std-string-parse-i32-trim-unsupported.diag +++ b/tests/std-string-parse-i32-trim-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 70) (range 5 4 5 36) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_trim_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-underscore-unsupported.diag b/tests/std-string-parse-i32-underscore-unsupported.diag index e667879..684113e 100644 --- a/tests/std-string-parse-i32-underscore-unsupported.diag +++ b/tests/std-string-parse-i32-underscore-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 76) (range 5 4 5 42) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_underscore_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-unicode-unsupported.diag b/tests/std-string-parse-i32-unicode-unsupported.diag index b9a5741..3e160a4 100644 --- a/tests/std-string-parse-i32-unicode-unsupported.diag +++ b/tests/std-string-parse-i32-unicode-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 73) (range 5 4 5 39) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_unicode_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-unsupported.diag b/tests/std-string-parse-i32-unsupported.diag index 1e3d5e7..73a8d2e 100644 --- a/tests/std-string-parse-i32-unsupported.diag +++ b/tests/std-string-parse-i32-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 58) (range 5 4 5 24) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-i32-whitespace-unsupported.diag b/tests/std-string-parse-i32-whitespace-unsupported.diag index d38be9c..bc6b616 100644 --- a/tests/std-string-parse-i32-whitespace-unsupported.diag +++ b/tests/std-string-parse-i32-whitespace-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 76) (range 5 4 5 42) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_i32_whitespace_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-parse-string-unsupported.diag b/tests/std-string-parse-string-unsupported.diag index 4808388..18b59fa 100644 --- a/tests/std-string-parse-string-unsupported.diag +++ b/tests/std-string-parse-string-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 68) (range 5 4 5 34) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.parse_string_result") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-scan-unsupported.diag b/tests/std-string-scan-unsupported.diag index b5ae6e5..49367c5 100644 --- a/tests/std-string-scan-unsupported.diag +++ b/tests/std-string-scan-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 53) (range 5 4 5 19) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.scan") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-slice-unsupported.diag b/tests/std-string-slice-unsupported.diag index daba651..580b8b2 100644 --- a/tests/std-string-slice-unsupported.diag +++ b/tests/std-string-slice-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 54) (range 5 4 5 20) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.slice") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-string-tokenize-unsupported.diag b/tests/std-string-tokenize-unsupported.diag index 7d233c2..759bf81 100644 --- a/tests/std-string-tokenize-unsupported.diag +++ b/tests/std-string-tokenize-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 57) (range 5 4 5 23) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.string.tokenize") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-terminal-clear-unsupported.diag b/tests/std-terminal-clear-unsupported.diag index 203c292..767efab 100644 --- a/tests/std-terminal-clear-unsupported.diag +++ b/tests/std-terminal-clear-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 56) (range 5 4 5 22) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.terminal.clear") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-terminal-echo-unsupported.diag b/tests/std-terminal-echo-unsupported.diag index 7d25a3f..00bbf13 100644 --- a/tests/std-terminal-echo-unsupported.diag +++ b/tests/std-terminal-echo-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 55) (range 5 4 5 21) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.terminal.echo") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-terminal-is-tty-unsupported.diag b/tests/std-terminal-is-tty-unsupported.diag index 7009eed..ec9ea9b 100644 --- a/tests/std-terminal-is-tty-unsupported.diag +++ b/tests/std-terminal-is-tty-unsupported.diag @@ -9,7 +9,7 @@ (bytes 39 58) (range 5 4 5 23) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.terminal.is_tty") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-terminal-raw-mode-unsupported.diag b/tests/std-terminal-raw-mode-unsupported.diag index 897d9fb..057467c 100644 --- a/tests/std-terminal-raw-mode-unsupported.diag +++ b/tests/std-terminal-raw-mode-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 59) (range 5 4 5 25) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.terminal.raw_mode") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-time-now-unsupported.diag b/tests/std-time-now-unsupported.diag index 23c44ff..6c7acc7 100644 --- a/tests/std-time-now-unsupported.diag +++ b/tests/std-time-now-unsupported.diag @@ -9,7 +9,7 @@ (bytes 38 50) (range 5 4 5 16) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.time.now") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-vec-i32-push-alias.diag b/tests/std-vec-i32-push-alias.diag index 72148c3..f5a3fd6 100644 --- a/tests/std-vec-i32-push-alias.diag +++ b/tests/std-vec-i32-push-alias.diag @@ -9,7 +9,7 @@ (bytes 44 60) (range 5 4 5 20) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.vec.i32.push") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-vec-i64-push-alias.diag b/tests/std-vec-i64-push-alias.diag index 2105a4c..901e8de 100644 --- a/tests/std-vec-i64-push-alias.diag +++ b/tests/std-vec-i64-push-alias.diag @@ -9,7 +9,7 @@ (bytes 44 60) (range 5 4 5 20) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.vec.i64.push") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/std-vec-string-push-alias.diag b/tests/std-vec-string-push-alias.diag index 381d347..f2ff3d9 100644 --- a/tests/std-vec-string-push-alias.diag +++ b/tests/std-vec-string-push-alias.diag @@ -9,7 +9,7 @@ (bytes 47 66) (range 5 4 5 23) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.vec.string.push") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") ) diff --git a/tests/unsupported-standard-library-call.diag b/tests/unsupported-standard-library-call.diag index 12ea857..bd24de3 100644 --- a/tests/unsupported-standard-library-call.diag +++ b/tests/unsupported-standard-library-call.diag @@ -9,7 +9,7 @@ (bytes 38 55) (range 5 4 5 21) ) - (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err") (found "std.io.print_unit") (hint "use a promoted standard-runtime name or a legacy intrinsic alias") )