From be6cdfb87caad37bac8b7aab1ca98e546481e220 Mon Sep 17 00:00:00 2001 From: sanjin Date: Fri, 22 May 2026 18:07:24 +0200 Subject: [PATCH] Release 1.0.0-beta.7 serialization foundation --- .llm/BETA_7_SERIALIZATION_DATA_INTERCHANGE.md | 61 +++++ .llm/ROADMAP_TO_STABLE.md | 4 +- .llm/reviews/BETA_7_RELEASE_REVIEW.md | 37 +++ README.md | 25 +- benchmarks/json-quote-loop/.gitignore | 1 + benchmarks/json-quote-loop/README.md | 71 +++++ benchmarks/json-quote-loop/benchmark.json | 11 + .../json-quote-loop/c/json_quote_loop.c | 118 +++++++++ .../clojure/json_quote_loop.clj | 42 +++ .../common-lisp/json_quote_loop.lisp | 47 ++++ .../json-quote-loop/python/json_quote_loop.py | 53 ++++ benchmarks/json-quote-loop/run.py | 13 + .../json-quote-loop/rust/json_quote_loop.rs | 62 +++++ benchmarks/json-quote-loop/slovo.toml | 4 + benchmarks/json-quote-loop/src/main.slo | 56 ++++ compiler/Cargo.lock | 2 +- compiler/Cargo.toml | 2 +- compiler/src/llvm.rs | 1 + compiler/src/std_runtime.rs | 10 +- compiler/src/test_runner.rs | 38 +++ .../tests/benchmark_math_loop_scaffold.rs | 1 + compiler/tests/promotion_gate.rs | 192 ++++++++++++++ compiler/tests/standard_json.rs | 226 ++++++++++++++++ .../standard_json_source_facade_alpha.rs | 249 ++++++++++++++++++ docs/POST_BETA_ROADMAP.md | 10 + docs/compiler/RELEASE_NOTES.md | 26 ++ docs/compiler/ROADMAP.md | 8 +- docs/language/RELEASE_NOTES.md | 32 ++- docs/language/ROADMAP.md | 12 +- docs/language/SPEC-v1.md | 32 +++ docs/language/STANDARD_RUNTIME.md | 6 + docs/language/STDLIB_API.md | 37 ++- docs/language/examples/README.md | 5 +- docs/papers/GLAGOL_COMPILER_MANIFEST.pdf | Bin 73657 -> 73657 bytes docs/papers/GLAGOL_WHITEPAPER.md | 61 +++-- docs/papers/GLAGOL_WHITEPAPER.pdf | Bin 368483 -> 378100 bytes docs/papers/SLOVO_MANIFEST.pdf | Bin 161096 -> 161096 bytes docs/papers/SLOVO_WHITEPAPER.md | 47 ++-- docs/papers/SLOVO_WHITEPAPER.pdf | Bin 428424 -> 437439 bytes examples/projects/std-import-json/slovo.toml | 4 + .../projects/std-import-json/src/main.slo | 92 +++++++ .../projects/std-layout-local-json/slovo.toml | 4 + .../std-layout-local-json/src/json.slo | 78 ++++++ .../std-layout-local-json/src/main.slo | 92 +++++++ lib/std/README.md | 20 +- lib/std/json.slo | 78 ++++++ runtime/runtime.c | 99 +++++++ tests/std-abi-layout-unsupported.diag | 2 +- tests/std-async-spawn-unsupported.diag | 2 +- tests/std-fs-list-dir-unsupported.diag | 2 +- .../std-fs-read-binary-unsupported-alias.diag | 2 +- tests/std-io-prompt-unsupported.diag | 2 +- tests/std-io-read-line-unsupported.diag | 2 +- .../std-io-read-stdin-async-unsupported.diag | 2 +- .../std-io-read-stdin-binary-unsupported.diag | 2 +- .../std-io-read-stdin-bytes-unsupported.diag | 2 +- tests/std-io-read-stdin-unsupported.diag | 2 +- tests/std-io-stdin-encoding-unsupported.diag | 2 +- tests/std-io-stdin-lines-unsupported.diag | 2 +- tests/std-io-stdin-stream-unsupported.diag | 2 +- tests/std-net-connect-unsupported.diag | 2 +- tests/std-num-cast-checked-unsupported.diag | 2 +- tests/std-num-cast-unsupported.diag | 2 +- tests/std-num-f64-to-i32-unsupported.diag | 2 +- tests/std-num-f64-to-i64-unsupported.diag | 2 +- ...std-num-i32-to-i64-result-unsupported.diag | 2 +- tests/std-num-i64-to-i32-unsupported.diag | 2 +- tests/std-num-to-string-unsupported.diag | 2 +- tests/std-package-load-unsupported.diag | 2 +- tests/std-platform-os-unsupported.diag | 2 +- tests/std-random-bytes-unsupported.diag | 2 +- tests/std-random-crypto-i32-unsupported.diag | 2 +- tests/std-random-float-unsupported.diag | 2 +- tests/std-random-range-unsupported.diag | 2 +- tests/std-random-seed-unsupported.diag | 2 +- tests/std-random-shuffle-unsupported.diag | 2 +- tests/std-random-string-unsupported.diag | 2 +- tests/std-random-uuid-unsupported.diag | 2 +- tests/std-result-map-unsupported.diag | 2 +- tests/std-string-from-i64-unsupported.diag | 2 +- tests/std-string-index-unsupported.diag | 2 +- tests/std-string-parse-bool-unsupported.diag | 2 +- tests/std-string-parse-bytes-unsupported.diag | 2 +- tests/std-string-parse-f64-unsupported.diag | 2 +- .../std-string-parse-generic-unsupported.diag | 2 +- ...ing-parse-i32-base-prefix-unsupported.diag | 2 +- ...d-string-parse-i32-binary-unsupported.diag | 2 +- ...std-string-parse-i32-code-unsupported.diag | 2 +- ...tring-parse-i32-error-adt-unsupported.diag | 2 +- .../std-string-parse-i32-hex-unsupported.diag | 2 +- ...d-string-parse-i32-locale-unsupported.diag | 2 +- ...-string-parse-i32-message-unsupported.diag | 2 +- ...td-string-parse-i32-octal-unsupported.diag | 2 +- ...std-string-parse-i32-plus-unsupported.diag | 2 +- ...td-string-parse-i32-radix-unsupported.diag | 2 +- ...std-string-parse-i32-trim-unsupported.diag | 2 +- ...ring-parse-i32-underscore-unsupported.diag | 2 +- ...-string-parse-i32-unicode-unsupported.diag | 2 +- tests/std-string-parse-i32-unsupported.diag | 2 +- ...ring-parse-i32-whitespace-unsupported.diag | 2 +- .../std-string-parse-string-unsupported.diag | 2 +- tests/std-string-scan-unsupported.diag | 2 +- tests/std-string-slice-unsupported.diag | 2 +- tests/std-string-tokenize-unsupported.diag | 2 +- tests/std-terminal-clear-unsupported.diag | 2 +- tests/std-terminal-echo-unsupported.diag | 2 +- tests/std-terminal-is-tty-unsupported.diag | 2 +- tests/std-terminal-raw-mode-unsupported.diag | 2 +- tests/std-time-now-unsupported.diag | 2 +- tests/std-vec-i32-push-alias.diag | 2 +- tests/std-vec-i64-push-alias.diag | 2 +- tests/std-vec-string-push-alias.diag | 2 +- tests/unsupported-standard-library-call.diag | 2 +- 113 files changed, 2073 insertions(+), 128 deletions(-) create mode 100644 .llm/BETA_7_SERIALIZATION_DATA_INTERCHANGE.md create mode 100644 .llm/reviews/BETA_7_RELEASE_REVIEW.md create mode 100644 benchmarks/json-quote-loop/.gitignore create mode 100644 benchmarks/json-quote-loop/README.md create mode 100644 benchmarks/json-quote-loop/benchmark.json create mode 100644 benchmarks/json-quote-loop/c/json_quote_loop.c create mode 100644 benchmarks/json-quote-loop/clojure/json_quote_loop.clj create mode 100644 benchmarks/json-quote-loop/common-lisp/json_quote_loop.lisp create mode 100644 benchmarks/json-quote-loop/python/json_quote_loop.py create mode 100644 benchmarks/json-quote-loop/run.py create mode 100644 benchmarks/json-quote-loop/rust/json_quote_loop.rs create mode 100644 benchmarks/json-quote-loop/slovo.toml create mode 100644 benchmarks/json-quote-loop/src/main.slo create mode 100644 compiler/tests/standard_json.rs create mode 100644 compiler/tests/standard_json_source_facade_alpha.rs create mode 100644 examples/projects/std-import-json/slovo.toml create mode 100644 examples/projects/std-import-json/src/main.slo create mode 100644 examples/projects/std-layout-local-json/slovo.toml create mode 100644 examples/projects/std-layout-local-json/src/json.slo create mode 100644 examples/projects/std-layout-local-json/src/main.slo create mode 100644 lib/std/json.slo 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 2ac4220e1f229cf94e5dbdd2a3def7408b3374e3..ac002275b3cbaeeb67133a73ac29705e2172d042 100644 GIT binary patch delta 30 hcmdnFpJnHMmI;ZhW(FokMibNIAdJS&t(}Yp@&KfM37r4{ delta 30 hcmdnFpJnHMmI;Zhrp6{F78BFtAdJS&t(}Yp@&KiV39$eG 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 f814dd3a0458db3c564191b6935317bcf9e76422..a9a06381ad4c5a90a30386da1907b286310b574c 100644 GIT binary patch delta 180845 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%0DIx5^O+f-UP}EVTI2(5f zMdK1SC5BVyEj+2U?}~|13fzS3qq8t-Qz|d zRcFO-VX1Tc1zb}W7@PC}We89TW$PcP%TJ-@WDH`_G&iCHxJmd6#Ls(J`xj1|9JB6Q z+`JyEc^{hs2WxWQQicjLLp`j#Z>i6IzKdQ{KfqBEbr&4(635dv92`Cnb;F#x-5!B$ zOOXgvLmIKts`hmWThfIkz5f7k9C-+ws>=_L*=?BmdY^$yJ@V%Bo%jeu+WarfJn0c^ zZ5OJmbRdj1gb^V$^RZYt_WmKzv*s^Mq{tIM_UjW6DyQ==R95}5KpFYz)NV9q9wl0x zc?>a(9wG@JWZv^Unl(?Tw{;K(pHNDENX~UQjQ01TlDf?WUdi)X2TCNCCjBE6kOZk@ zARl3Kx-<(|*qkoSjum!_OW1EN)q+f5zx|EwxEP1E!qrRIBfuB@6ka>TutDE|sJ@{} zMCh0UsoX5_E-lp2r8h|EfEz}-=*i-8vozF_pv`N5R#=NJ)gc+>a;YA$cTfGqjdNjA zA>IWFLWZAVb!qhg3YF4<$BSpMk#QEzwF8clt3T5~tRN%cE*om&)##Ef*37lcCK* zXyft^E$OR^ahxK|(W#z0LNlp`s7n~85OYE`}f3Q*O z@CFV9LN8^b-2NLL51k!F_AHVl6&E~X^c$P>7|`|o2V4~M27-vU$Q&-5iTYq!%&Q^H zWqrpiH%)ER8#Lz2>0ufE1ISJP1`8~GYwR*Y%f~Q~6AzjsXjDka;9C7o!w`&Z4r1M> z{LEk7m?s07R?FzHv*zzCrB%=~h1zt1C?HodCaqr}hN|UKLRhNuAQat1gS0FV?A^+} z_YbT=<6)&fXoaw~IW*;-V|E|j8D|&d4`NJUkKbeY#Do}+FnjR&L zLJNA-`<1|-WFz?d_%6Q!@BF_Qky3OmF)DPd#7l(BAi{*7vM2W$9_$w88QCs3K3TlU z=!M<#=f4!^CC=Mp|zP@>9u;z-#g;v-zbqIQWrhD%t~F0pNJiI7v5mJFos zv!h(Xly?c%cMGG{E$n8uYP4pJa%)*IBH+|55>RH&^-t8xC#pYm0KRePP$IQkHC9=f z0959x(+%3qkOv6>r7a2~+48{AF*PsZ3vA@eEu_%Tc?v6;gM?*CM($*4OhT`aTQynv zhS9Aht*ADePS8P6bN2&{2ir44J0-J9R(Y*TDYmM+62!U|0Il@5f>B9kh)N;xZs9hJ z#hzh+B1X+_993O5w`#V|tfq*NF#yij2ZK|{7>f+VSbTb|3o0S3b0Egz^3W~PYmcTz z|LapJwEF-;!u3|5n@zh#oZ~~7f?JirG-v1#1Rh1Q-4&Gvip>?xcBK)0u-?6qM_n}< zvl^WmBc;$1=XY95cQo6OR%^MiJ6i58jF#V}Nx3BtE1)sc**ww765NfX+nh>qSPSKI zDm!u2m^SW9w1X25Kiw7SiGk;Ok`;~ znuvKU#4+))5d8)ex0xqKL(6Gyv|OGSBhO0@ZlsnWIw-LZNvjmbkcfw=$dWQ9H{5Gi zqRV%2;xYRM`24kiH|d7^NBmV8FdQQY8$-Xte3zqw!_3WYZAtVlPVaWm3JJrm4X%+K{80 zFVkDC6D|irWEyx!*5o&?sZk0jb*>h-ps}?L@DYuTLDzPTHK+XV4P|r6= zR7My4oRTlGp`o6ys^wN^gC!=ex>_FNDY;S{&&XEw^YQa;&QU$$(CVGmDpWt1k)>>8 zOL8#5P~ogg1+;rY5D<`tc6z3�q?^O^>q_oh(`0ZVC-75bD+q=P|I<+i3L6Z}He$ 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 delta 172750 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 diff --git a/docs/papers/SLOVO_MANIFEST.pdf b/docs/papers/SLOVO_MANIFEST.pdf index d8e3c9e88db59cd9c36d940ecc5395260aca0326..f14877778f202f1beb580487d26c8e96823d3368 100644 GIT binary patch delta 33 kcmX@{iu1%P&IyUEW(FpPmJ`$DAdJS&)=tK)olN^n0M*?L8vpOV 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 124adaee5e005c4db90bc99a72a4b02545859210..9d287ce09c7b6a0baa76483983e818e3764b511b 100644 GIT binary patch delta 232699 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%0DWdV1@q>e9& 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�_vcrlmypPNwV;WBt0N_Zo&g{3%V~e2mIW4&H)VNQzfQi8xG?O7L%}rECA% zXnLG2$#t~Htz|O()LW0BIbssVUNFgOZIZ^NRh)vmkc^>uorcAJSFNePim4Fk_`T%& zF4sALBVd7kk}YgS@j`k@y`N-BO$aHlPbH_k65p1u2K}v#%6HT`Kv4@x^^U8kA56s$ zVsvihuaf6!g?x#b`iyG&M?4Edo~G`%t*~Tg*5x~!1w@g_9rPf17=d^<0hGyxxvIF^ z(A_T3A(=cCHJU0hw9eL5MRrv4pIuook{vK=w-4`<<)ZQ!4^eJIsy&wC#u1CrxTd|Y z$x@jfQeFY7?j>?+p;d2dcSe};72E2cr&2ItHc-!p7VizdTwT6}5F|iIJ$Zm;u?aJ+ zr99D1DX#`<*w47a2kL-foE`lA3ElNbxXVmN7_muHmYPJ7y)RB(#mH$#!+fexaRA)X zbG$G<2NLjf`>>th>{wLx+j)QN68j&U{NJaFJ^8%Tj@F$;NK7=Cuapt=T0^OS?HF7Z z)lM7QVDf*?WPGkC-g5+c0OJA}Ui;KkJ*%uPdjllBF+m zAS7Gb@(Y|mH76?3jAU)US>FHgcNDNl;eQh+Fh(h-N0s!k;#`I{5Qou8`z_vO-W%6B z>{)wPsrgu{G#vc6Z;pAK{Li~7o|PATR%UK*knX9CGNilY$1#ndzJ>fqt|fuxsZ7Cx zoDr+Z?Z6HW^!|^f8o8ehql42vr2}noo6>trj-S!AE-9*zDP%%9Oc2T3JLA9wPPLlf z+4jMpYL*Z8M5h{J(^g~qRFCjsqt_Mv>Rx!qQxf)`S4yzG8v<7hn*!m&&CDe(57?%)AeZ z5+jelam5BL$z0%)qx$TYIiLh~;6Vz! zD3UAKteO!SPK8mcYfo>%q;@-SYArdDq|x}2u;x8+sCVWd3jqFIsm^q#LWue_$3p!H zE|qF?{8CXE$rF%yJef{~h~)UC{Wy{*u|a*XOR>;5o`2&o-;}4Q^8HEA(Xb6;+^W73 zu`tp^ZH+Ye83=2!tEF>8lE$#rqK|*u7$2|xR*_s@>5NO1rc&}P5-oR= znRlho&Vxzi8^C{SN)qNq`jWu!rJBoG8U6~9qjm8PmN%#Pfo(Y!OW~)CnG(cIYXZGx zp3)0;Q?Y})m8({T!9L1~$VxQ~BPj#Ru`SgL>LfKJ|6?&HYVWFx6v;#l0dvs+B#W!4yYHRG?>`Vj|I~ zauaR`t)-8IYZmVIoN34|+=b@(Zg~%9AA(gY z(nS8ThWJ8pBdMWj)tbX%$a)Q?Q_s`!WBL>;J<8!OM7T_-*lW^Gvdc~xRdX%UC55u9 z{_&Zuj`-ozKaid8Qj7uQZ2St%uSyf)_{qkunpz@qMs5rlooq#$GlJ|&{YrNlc_2i^ zW(;WsDX}V45MnoJ>I@Za4rMWI*#OGQyO?Puo7yxmvdI*-)ipeIDkc?G%tORi+~Z61 z!vDOMB&RLYMkr!WQ-&(@T>@7X&2XFRM|JJv^bptFf%4&&XpLpW_CN^Secr!L zE3DXIbboNzaOeMTl_a`;{4f9itrNxE8L`xd=uA4Ybro=v0+b>Wq|>9qWQ2kxN|C)^ z78NcECl|eoD6(xzMQ2OHzY?(=!r3a+4%3U)YRuvOtCA_q6CiuE{EMtum)o9g9>HEt z&ixz+F?xur4>`k7UbH37P+;TN87?M}pR`1XBx`&;zRSHOP5*_nUlG})p2bR$5U~G~ z8138ruhC}_3LciJM25XD6gwSWOE7HdQlyp*0;5Tc-6lWg*wSFwv=1jRx*1{vBzS4L zEE`y&S9SLppn+&}VNm;OnS&C;J~qheW-!iA{mXKhx9mX*!hKIo8wdsa@&0FE6@PLy zGo7~Ux*B=jfcVd%g=x0X2K|oF=Y6aPA>~Y?%vZ)cqk!&p)IM`mJ6igt8hn9H|B5IeQAjqQ9zbmZ zDR>F72?xcTsRcb~fzvNzG95Kw%*01C2Nf;h(2ulCL{G_Ej!<+dg}g57ar%bJLKWSC zrHGODk}FR*j)bx5vgCuML~-?#lNLSj!B5vHCbbBlvTTq9tp3YIl@q7 zzou8!@6KdGK2%9k#It1Hd!_ovyn?I@hZaY7Ib4aRGu?TwRzfUq7t}dIxc?&?CT0pa%|u!c;~8tKRoigRHO1)v zmRNzhD>TBeGWX!U0tX|V&cHxxvSGQP35UP)9P0=LYmj9rTc|+dB zp2R`lI~6d9^rNyp*rdqnPkykPg@PCw3cgdWK(uy`latz<@-N^u6M31{9@1kB6w|~D zI#fu9IX=zOTf3N^!CDfTPUZ#f-Z{W}I>qWlFB=yNB&E&q?UpynAJh0?k(7R_zi?JA zwVuqUuYomtrrgCTtT&EPaVESt1pTvBN_Z{Gc>|8;XIImQ`7h_6S8<2bO`U%`Vs~mK zw1o$KxwtQ>+Qn{Vv{3<^4YD?HCH52!EWLV^A$TAtf~JpKnSREMnF#c$ z_3av8v_3Uv(Aw?U>R{Jr=B&O>Yz<0#2A3SF4G(WkRf`=*v+HBHpq&fd>0yaJo?>1< z*#%hn@qZrY*9Gv_sC**N2L z`CFg?9D(Q&P2TjdXuW_eRA|-ErYEgKaTWlZ$3B&C-C&Q0W4*u|31x0=_NJc${pjWhgRI&dDU?>(3~n;!M)O#O&#BuR)ZW9 zDW|AO>buv;+n^P=-zc4(Kv)xx9iWTv>3{)oPW-j%NUtFTW7GEaW@gI0ks7E}B5k=c zjAdLfNF~N?YAYDS*Tsiq-0Rw+RsR}}zul!F+z_g}L~FMM8`1rPU0g{X5Az>-KKH_bgV?}W-84UbENjoJNYe4F;%_#Z8(_FBdD`$krcYgirEM~PTqrrivG7wC zXtShfrJ6NQ%F*Gcz!G&x0(1m|Jav0MQV|#{oU0!^uRE8&>Nq^(7+6ah!|PgxS5)_Z zM6kdns^x;l?_)mnh(;MLV|@_jUqo@=>h#yBt|Rh7*G;f4HojAp&U}}_{Ui2ER65-8 zS3JcE7`c2RjtnlkTc4n?G}<*hx%>c*O!}||l@&>LUST+ws5Bam9#B?jE7d1Qr!<=@ zBmX0as4je(X6abYjmE6`bI6m1R zHMwC3XqBkda5}e{+woq(>~Tw{Pd)`q;F}Zw_Cb+<2fg?dvvLdNe&)fZ#0;uiDY^)r zr|r^YxXcur=g-*O$-F%X+Wx7>!tUr69}o?FyAH9gNZ*e?kTJ-cw`3hy_1RZ{|3}i? zs+M-wm-sqL+LAB)HafBv-oIf$cE=^(q}JLDs9oISu$w#)IqRDl@1bU@;r`e#c)(q# z;M*OfeO$S;RTDYaTYi#b5#$>e6mUA|$L!WJZ*)xC_dHGV;64$&7#O~6wQyPKe7Ml_ z?diELUhK@^$7;0KNpbc|;*z^aYdEQFY;jHIr3g+>Pi|c=rXDW&<`ZZrykVT9m9~-% z{9}x=5Ugq7t8w*&r7MMd=B_EM>NhczUJnWBiO1cN3npSH_eAJeI;bTAF<^Uu0T^!m_(ajXeLe=yq=L%C#e5Ut>7L)1aBUrpI_l zO4GNpY^M4_qm}-cddB<8YB0Lm^a!ECBfR4F% zH-@k~MBhq+ke7~$23*LXZySHw5)tV7yV4V85Fu%;sCasQooxhuMv3!TT95C6W18^6 z4W@@_4ljs-yf%jX5sM?AQSD%lgxXRWsT@UwppQRV=K|-{+zuTP4{V-Moe&R&+L9UL z4jmcTi6=m9KN*16&z)Mmj|V~lHhh$E!*;NL;U{%4p?;IE+2FpIT$+bj#V~&IK zeLJ|=9M=nM%>^#95H5rdKZriBgC4?jQ1W%Pj``LpYFxD2;29nQV=5V|o~wR>f6;{K z3=%T=c-2qsfDF?UAMwe;e*}Ah(_1Yq(qg;P{qBE3EL1IYQx$k9ZUHF&Q@_>0KXhI; zL}rB;4_S}AY5LjQiEYh|D#o$!3y}?pnh36UOh2XZ5kWw zQ2V|*=%43X^y@n#gp;6=cLx*O*wcjhj*YF?VnI|r<3I_=J8Y^BPR}GXH(R z$_WB-tvX=N^N(!BvrIY>Oh4y~vHbn@p{jfq&9P!hx){0wdpKXOSvVJnsCvx8`5*_{ z8quZaoJ#y#KF39>1d!pTo@BMC7Ac1VySmUZ32)5mmFnulAhWX4=!Ev8F7s?Ll#o2z zvF$K#kP%Cg!%7^v+=O{U`b$@r@exZVLoHh90F;tjc@o&ej8bBfgA`^48t)KZCtYc9 zr;{vC#IQyc@xBvu zpAev0Y;VAY@1lV$yJAHQ7kn#S*WatfvUm7}?ZfbIvUVw@JNhzyRRw_Ax~PmAf87Qq zI_rRH=ywbB;BL+@o9w=MDtwYoE+JL!f`7ctipIUkFHA7c)Fw-c9sZ>!y(yCsAl zZ@`E9E7IrNvEYW^>nfhFc-J%H80B8aS?uHc9gg)T4p-07eBVbG?a#ru<;m8QB&H>c zf-1-^&(p29tfZI{)yc}8(J3L5C1?Q6tD7usz1yHC!xElZjh$=`GwvpT(xv>DmvYvN z&vUd+vj-j2bJSQMVWg1_cRy(HRB%OGhjC2PpF(MmL0|?MQJ<^4@JnslHjRypZ&OG? zsXEV?KHNypvfdNttMoReBeejS_*-i+oPp=zJ$c-Kagd&;ppJ6S>4h<1Mh)y(e4B;H zGQ!)JP4sH>Jl&o&K9BQ4FwXU2IFr2m|C2GgjfTCqat1EYW$^2Wzvi)GC zh06=`pn$u2Vllgvm)U=AXRRZhV=!hOoQHLlm(_3-q3WXt;ocGZdxOUTORi~g)Kd|h z(emob@2S6WNAHQ|k{cT(3$;HBm9Md2_7CMS_snFhOFoQSKd$_9{7n{4^j322Qf$O9 zP_Gjx;V3&DW)G8oY(FPwYY&r+r*fb3TvClNAeeAg^p*gcS1H(KNBzbdZ7f+ zFuoV_MFyd?EiCnP=D&xfUjB4KMA$8{54w*Eir0hu z|A^^*l?e{0s;bnyFBHs=h54Yxt#0IZmJ-SYCzB#NBWMlLy;bfZ9UEhe70V{E?dhB@ zqz79k=xbnq=~!bJ{@Lj~%wDosL%Z|Hc>h>IyB|UL+~pErv|arv4gFp@b%ddRdk}IR ziT+%C=rUq-p}}zA(=uuk@w~Us<#b+-|Dn&|p=ge^)OSL4@@_U6iD&{B2KWhbZt#lu zP((gF*?QEAxRzVHBUQCi!D-H4R(a!(P_Aa^yzf-JY=^p~j$kS>Y(KVpn?(wTn+U^T z%p(eiD|11Ti}6B}i=hRg7KE5fh-Dgfi=l%k8$|z?cPlK`X2o%IHdy6gV2&)NI1s=KPru8mLe+#U!ybL7~hJzn+m{UNIRR zeZ#7toG`sq(s7c(dOo|8Ru(iU?Nhr3L15NW$%XTf66BmtxHSh{Dv4xO2MtFjEc2XjMG5MbA^E8n0k1(F!jw>oJ%nArUUY7I* zQWxDReDo_{0hE11H6xXGTiBtgq{Q)8h*p>FoJCotyJN zIDb*Bhzac&v+mD?qqh;?7ha_dg{{X3M0!xor;OyY40_;Xr?#%D;ucN>kmL*P7Uvhc zFg`vXg@-}Vgw64>XRc&tL0yUS~rR+oQ+P&Yar z5EC2D`Hg>dZgqZ{$6cs;S75{!MR~Gey}ufF?4w*=y|p#cVf1}IXRB~>DQ~cuPq=#@ z?Og1-ceI`DELY1q{&>B*d71e3AyK8?DnYHuZ4T5!aOqyHJX(~wSZv3fT<3$3736%n zpZq<`*K$88r>GEp%b6Dyh6$oLy-TPZLG(c9;y;A65bNPW?e{U@>(PRc>#tL5KkOhK zN#i>cUi0k()|_1-rZZX7U;ik9wYgh3v8J@B9WXn^hw^ z>JI`l7`@c(i;UH^kF&F7UhohG!<#eIg2k)P_t489oY&Q&`@Y+&!1rR&$LL%f5qyHp z@;@hdKY$~j4IW~12M@>0Lp`1tIH*9|j@DEUx-ggD=4?D9c*qzNbj8!(2s~tDl`v6H z)pfh0?;LVO?-ug@rWRGe<^>;BDzU=LgdL}$x261*kj-fN2?|kZv;7MO$hKa{qa^T9 zetHLRGT`gCssD{jjw?Zc*r>?k7yC*_c$D2RDx_J5r>qah^2_BlfetNWWDEhwYcH$n z&mw)2k1->Fn@CI}W}fEjnRGxfyGfxPZ%54Tn_YHv~b*?F2F&;mmgXw%TEUr+jOrY4om5fK1hlL0<#cFgkC9I9sGaS zH3MCI2k@P#uli+*Xf`%PIvttIlpXEI{z%TsmvG7nLN9J{St{tRb9J)BtO5=po3lna zEX)%d*9h9NTGlmxI=)uL5f@~;r~T+cZO;B+?)+%b+hY>nWZl_*@&o=9NNs-1LdnKd zjQ2|Q00T2*iA3ty68fxv@8GrmBNh!8%=7<6tUyPd^XK)$4QlfU&=)=| zJo7084NuYm#r_;*xU2_Ow-f0WW3mS<6y1_z*{W^z>I~MIYY!6qifRTlEW}wju~Ut? zpxm%%P$h-=9FonPq|umq%iy_CU6RCHk}$NaULmx-GA2b=C=S`)$eZHVDXyOe?li8} z$o}<4bu$lJlqp!Rw;M?G+#rfD6s$>Q8c$)tpgXVz-Xbqcc{ME+%de8gv!fqQ{2}^i z@J%To(Jw!V*MB`>EX$G>!L6EhUC_Tiy=e(|QF1UVQ`nW(Y8{)XM+_izO2p@V0(pOV z#Px==H&CQjDL;*zG--B>Kq#OG-ty@a6hDr!rt}60#Y>~Uepx05T2E{@hW5M55N3~n zc@_Eqg$G>e9c<|__Wzu~c0c7pE%sr0-S=POh$grMT>JSyn)#T*N_E1UEQ=3SD7ikaBz9JH4Oqtuo@s}5I8c1oD>!TN;?WOKc-4zdBTKe@(Ugx+*4gI%+t|*#J`Pl0k~yZ5K$flUW05 z_t%d^rwZMU<4wiQDFT>M*Z-UTsq?1r&m&9Ax(1@Ft>+xBfUGB_-=|H>2peKgV3-Tq z#3MnXL>ZwAdYwpd+im8$f@%YpiAgm9mI`9&MU%gHWn;?8_bB`*Ddoml&?p5lk#X`J z0!gF8U5x1>b;TNz+}+s6B)=VqyTN`ZQSxCL8(iOZFCMqt+y`dxSKAD6yvAK)5IXu) zQ*~daROV9*{4^PLq1z+ut*X;1;=0P=Mboz&H?3)2*?nNKlBeA}I^wbBJiR*MC$o1` zTNw^|b*LeDE3PCfOYl zr1r2T6)-p=-qIs4uLrZb0n@Wj^LTH-Im@MHeW#k2w`QPl1Mz5aAvkaf>{%OpSPi-N z`0T(?^2*35>6;_`3QnDe?T@w787KHBcSL>f5rf)fsw_>%;p9u_clU+wmaazAn&%sN z*TYxGyceq0cYOw{PSBUY{i6^~3Or?gfhe`vZ+X#*$>9{=j?kc)81nq3q_ApB!XR+4 zRq5Czu{d4ABtl}sxFs!b&z*!SXZ;S~b9m5{aSD?sqX8>Wo(N^k!NuiEb)GimwPCcq z1e~6IOq?H4Qq!jwm2DOEPwa z1=G`}-44yk3uQYaOTOEI85}(PpIe_4?zk27uNI4!v6buNpFvp=G3;{jcCvA!TjwEa z)I2&lPjR8wj+$Fq6%X$xUmLXaGq>+7q*m^9cedXcMm%d1xf(f!?rI*`%U(*> z6PeDa_*?>2ybobAr(~l<@6t8D@tZc8vC7_=HFnmBLu``Ga@T(NyoR~9f@xV^?{3?v z2aPdy<+I!(jq>%+E^MPhSg_q-os^~-TkC-6w+wM+^3N0 zRPTZ4Qp9*B3f@Sbw>$%*3qXk31whB>!Z`;bjZp1CjZo!*jZocy_W$wI{At5#eZ1&; zeYorNAT7dzen13GUi2opPW@XpnY_(IVa*$@5s!SL8%}M3jU|nIkJI3zx;?gv@{t?+ z3ez6>y6y2-qEi?#ni(SesV4zu?wF<$3o#mWS`a~t(flrsVnzQ)!BId~kWek90jN;I z-~6W-a$EY`mPZMH^SN!PXpfF4JBVU6Ix_~dfiZW(dC2&2@W6k#3jL?D0f9~ZdPDwY zqg%O=$`{=bdH5}OFW|9n8WAkxGKx`|+}~&NsV`)hanZRt_BdEd-}_4)?XaTn`bkh* zF!qvNYZo-k@?DJ)&~tkmQ*ra^cc{n6axhVyVRu^S?_R@S)!0Xl?8BJLSyyl{>Id)t zS1W|*$L@J^cjpZ6dHQ9I&-5fBQfl#W{!*8hga6D(Ev6gOD@(#|+0Td9KRG0RLO*Xj z!pN2(_cw;jg~OMDZ#RR_<8Q;N7*7m5N0tUzptK=s|BIo`I7_OgU~4_-G3A5-k#XDe z^@aw4gYwZz@R^M2S1UV4=11IOc6TOeVsvc6{L0h(ln-6Qfubg+(&`b@y zY2US@=a$AYRHrSZF*HVz@EU9m|{bP@*tN-;<6XhUH@b}dYi(?e7bw;dXppe1>W>mxom zV*lLsFvM!3Sn2HQ;9`%^jBngw3i#qX%!G1G2ni_|&M+lx47= zajU5PE{J=LKygjky~n+?SMi^q5pQykW^IQ4WLO&x+kthBkA@4)q+Tqvp+)bQfM${kG9^D94`UjPI(^{V0m2A(Pc^{$6r;1>+6v-VW{T)!6Pk_Ks z9Er+16UWu@qL+?8(_O}Hn0YOfLLC4X*X`Y8*&kmiR^69+7HS6#g(u1ehA=aWaOQVi zn4j-zy&wjfhLtM%dxCIOfdUrOqjcA+uQh^`B;A|!t3m?tbe##Ta>m^ppAErN%l!?k zL=6Kr=E?Wr1yg1}ju&A_Npl((p*6~q*}TC?ysB?+k=lHwo}aamuluQpFRxFwplIFZ z%x*FYAUSD|#h|bRLGU;+Y0*k@0yU;_C>5~ zC^2>*y)tVf{0%@|4`E8D_S@~9rWv|&5Vyrm0luvN4huz6h;3ej&a_!vOj}HrR|kgu z$@Lciy*w;LK}r}Vh(P;c=PVQ`S$1@2S@z$wvbB&JK|Uc^APZ(5T&(FwnK*c2Y%wJG z*Ku6I6n`-K3m}tus=%QA_n%%T*DKI?WgeG>Ct1hWCtw!=>>IwFuYZ^?(;`iq>o^zv z**8(=y<6&kkl*t-^OU1BYu$ykWTU-wyfU%KwHpQ$J>68EHFu;|M;%#)h0Z6ou>$Tc z?Fo%?EibwG@1)XXs|`dq1jeOYo!;}(47y7!7Fii)?tziI4)1w5`rRc`i>x-i_mN&* z!%1Orr?`zvgf%VpfCe_Uf z=)FV)vdi=J*Ka2Kndtr{IV2b`9B8aoj6Aj016w@q(yaPOWL#4scuiSM=J$PgDN{&^ z=9vj*Sn^id}Ql-IpI{tMKF@(%uGD8vRTbO$NSOf~@iG8AJ2^;-w&7Z1^dD?hs3ca^?Z@}bx5 zphwC7EAv(32#q zSHcnWueuQriMMU|>qQb$m(fTP>MvoU31~pO+CXRz^7tj~VV^IcM&r+UfXaV>N^0_P z(cC*GQmBQ0+q`IV!N?^Mr~DVkv$9jsjk9p1TL_JW+-akGQ&fO;?bN2r^{PF!e_3G8 z+vN7u2naQIkt!duu}&qf8CR*el?HglM(#J%Rk^cW-7%6~H6Xj@97ZiqKG9@F<*kuf^S)Cu=Lo zp9u~BFj+j9a2p!{5BMW}Iq9MD;$n3=Z|x1N1OB>>2vzye&2{srTF)L#B4kd!%-0Nc zo&=>*?+X47{}$rj@a`wc`1juF?v1@Y-w#moxuLqTVV|AcfY-M7+O-d~v+!lT(qy5( z1b!1eMkHFdopwdM!LB;R_MDo~T+zC->)sQo#m)LKauUDF6K-I7ApWLZ`3-fgHcYnq z2sq}7y!Yt{VSHr6%zL48{e=Zhd#$ofOUYrvwUndJ1T&x(Z3=sUgq6v)jjB&)ZMM}j zsBXE@j6Ja_t0bWpR(NA`BtibgK?wUn82yh(*Qy7|nXo?3B(FQ%98);7V5n*S+pcW~ zVVbe)g*Awg$t^z^vE`7z1I@54@z7U&0C0{))E-CQ6FB)> z(Z{?Jh?d%w*wMAum)?0XxR{g8O3$Td=N_49W+Li6;nQrhigT#&2;Jf6a5qG{fl{Ex z`_cV*^=?n|abH}qzWH$~`rgXuW}lGTNlEP%I?ukomiAG32CkaETFiT{MvWky4IEie zN%y!!fmSV*1xSL~B!@}!OToqhpcr=YoWHnh7dN=3+9B_OcQmp;DX1suE_%BM9U&KW z&mDKqf+ehj+aRY6Z|D;A%*t;0(CFHXDg&+zy)(n5bqrv7ta_IfG{uIZNvxQ`tl&qv0M~Q5v?pMtbju@mPiKhHD#S(9TwnvZdy)aLwJVA6 zjq~}UL}L3c7Fd4;*a;?81%jnWcZYohLKPe^$0NEt|GRzJW(#apT_O3@qBHH?A_L@zv7q+CbDX%BK=VA2MM)m)s(Skc{r1(H z7HT#nhjMF$-G}*>F?)9SK21G4w^j2&<_>uGC7he*SKiIgRprklOUDgP6yOT?+V)e` zPlCD`?;naYLY4N03}AG~Kpm<4+uU(3D7aCJI#hO4{{`%N_E1+E8Wn~`Kop8TQwY*l0RZ-b!7>>U zI!3WP5KFr)*1fTpgPTRQ`{{1yLjL;xg#n3e^L_v`qev4AiGcODwb2?6(-aLMppS! zVK355^b;XODWkN1Z4-!Oc{Z4+*3_-`tGV>qQ3`VG1|o6zs+7ka%I;1MDD;e3_Y9(c z!0{;Ia-!RJq=eH!JfSm9f&|C56p(rO>G$yLfC3d$RWDr>r0P>Fq}ML9GEGEWW1C*(i4_(P28jnJ=Ys;5XFP&=`Rw1 zjClwAZDn~xIRkY>shuKk9p=GONWP-~MN&O-o2L%VVvQ0VdX4fo?HZ-_@Xo|IaRF+x zs+94d@QoI787${T?F4Yz5)HwcKpBScXK8H6ZECs!Um!{QmIU@G@ie87nyh3dryBW$ zCS?lamta=wyld>06@BNd*uqt9BilW>`F(_xnySb#|&9Y?G~REDX;ShQ2VjDmcotX>bys6vnk zOsNNfmqdv#wf%D12L4!=a+Vr)Q6x-e-dn4aiXV^5Y`pY^6xl`T8Jga%6fDJoYpuM{ ziM(9H)?S#f%{L6)Zh=v92wt|UbS%8OybOMOlFr3l08Riy(kEBI^qsmFC_6UsqRvc~ zvcURkr?0+$K75mTu&mNH$kD`|bTK%=Qiu$m34l79N59KWa2Cpdu2Cu~T|4__F?o^kbLm#-T z1MuG_ubMPt>lCy0`K348_x*wMk$P2Z?b4ieU&JPz?9pQNYs=wS(nROpAjO3;uZ7bl z$e-YOEG0Ic{NrB$RDLn(_}MWmr}s;5SeD;(Kr!i^4;V&+3y8K3VVR$v#UuSdhqFmt zepidUJ|E*&QR-gZ{`0`j24n*_aoDUHl48UdKpxnc`s69T3FIjSLqAM|l7P;`{Y};t;1)~l>%gg9XAp=kFwFgEbf{vRYi(;EMgzSg9YV)mT3W$?gEsXmN zOiAIxew9dmb}k7er07^oNy>x%X}JFppE3cIKD0A6msBga?!dbD@y8t=w9V#a`Dc<% zn&EC3kgN4iZ_-3Jd$iP>?Oe)8w|><18Q~(JzbjZVfd|p+?Q32dK^3OGO^XsBcUu5} zC6b7KsQe9ZtcI`pq%QqWEVM-r7cz*1L$42`%o0sJ#x0^bcdYt)rlJ47($JFE1np3G zVY~lg)Y=C`F0B3K%Ya|pdS6<)?1gJslGk}#i8Qqq377I)HGMx<50pNFw#xMU$`D6bTwOCvH5@fbPO*c01;A?buez#0=4?>9H;yK68 zm1w-}rc}>qs?7y|rQ9bcBgbsMR8{{q$9^hj9g`x0N<9rRV%Z7v$oNx|SSGE<(^(d)OSnH|9oHrl<1<=gn<_xrpmfyT2m>lpDByUO8s$8qYe_3AFG};LkJrX zz6J4{JDmn5)gn|0Ym@9fw%kHV?FDb~J30Bo5HSV#L%eC}5(&iODEP{7ECO~0;UQR; z242HRT#UCsk9j1-rVY;04ft2rz}+YcJ&u9LDx_d_e1E?^Asy4w3M-BPb^GauFe-U} z@ttQm(R0k0b4&&-dDdOC90D-Gai~(DXJ=`NcyJc2wmZKC3zv465mdWD$b`+icc>-!%bWw!dGHk-Fs|kcr9#rg&V!kv%2d9 zR@|K2^h*~?-<#L6ldbUyU)Y&MVqtTZLuTC3D`^+$#id?l`gTGBAb7|ZPP4}c>8hvh zD1=D0ldwyb7rRS!1KR)NfqB#LS;J~EoanYOoJXJ=KwSrL3RxSZ=Xad2dxmLl-O+`W zbiF%fG15CpktBUKZcZ;V`IMD;MscDu&hl@vyT=!p_5+7v<(Vtis?XY3r4RJh3K6A zdQ8p!gLvN=ZMqCf99|O+?3_&8%9hS0bXp$kGOhqgoK}x9?G4=$@m=yP%F8bthJW3y zU5iII{JQr=?GN;tRU9E%hMwDqYzu$s9`oD%GNyoe6-yxPEVIM>bQ_rf`$Y)ZB`Vy0 zqwuH_r^Q7C+??BG#JFmA#Uyw59Le}H5*S|pX})tNno9Sg40Fh7N};69K!E@vWe`n% z#EZ`WIV9LUDR@3dvLZ)br`}%ef=r!0zJ9F#z}zDVK#v%Cu4_Fs2{OHzRJfR88|0iS z4iEE`{cq&F%O2NPQfe3ha+vaavPtmsqgw($NBoaO@l#O4!}*9YFja4|qf}H$6sqWo zKY=&dv03nI)%XRikSc67&1u?EsBR)myaElT)gykKSqun8+-zbvGrz- z9W`YM_!+69Gq5vBETM}*5m#p3ZeD*`^_45O?rOA< z6uZ{fm4tAHIk*dP{Bsgg+@dCpNyd1s`mTeUiA=h!RDE;SCbJP)^-+=Ex8Z5+q7G$Q zh{l$WuxDo<{@S9rJ@6N(e7*1Bv~8mBZH{ihe=@iz)FW(0>@B#aDDIZN=pyhSdyxn2 z6RSS?X38y{>=W42T}1@5mxjcYI8VX`5eQHq1cL*z5FjCrD0ZEZ4L(2$T^1tbQ#s5#rp?g{ z1WaX;&5?i}jM~iX{z%5++Q+y${`5agjmuWi1N=uItP}S7hOex*&J$zbDJzQcrovwL zRotF1(FAlQ$%gx%-p)uL5<}72WXra_23N<5`o)gzwmSdpM;-F}V!s8k4-yvi)s6yy z-~NeHiQxB){qOohlG%A+z7Y_2^b9l6Ap6>G9+Ync#~uBb>0&zZ>^vmj2#h;=rz5qD z9A#BtfQS_Q3)Z(IwFHm^67XNJsE^b@Cbcqb{~{40xjsW9A)tkkw$ArMSH|8U1D?46Ooz| z2PF=M*uQf^B5~f)I~=L`fC>pj1)Eroj&#pePS!_vouJP1Zkhe%adRD9)$6tY_!+=C zR2jdf`1FjJd7KU2#gFo2A++nP(sP*OKP7%$7wV58LOWlTA$mh+_#n3TO!*5#1ooQ` z%9kf1^QVjwn*X?jD}FlAJ$;7_g;&ZX5y`?XIM=AwrU&?&Q4}ITSZE&qjf8@N6#5=1drT7Q%*FoE-H@lr8`g@32u za{@WUV5$9;%*bCyIlnt2A~`n|!TeNbxje88en5C+O|>GMqMkazU))3j zO{!W@e9OiAfjC)*mR_sx^1cNF=a`LrOdvP~;g*oQh%c2B3^lYFE8cR>rtCr)(O;HdVw`Z701Mx;#PLHt zM(JDsfFKZEYZq`1@J{r_cB97OLzPq zu^l0_2>6TNA`gW+7^?(A&xE3#()h$v&X+*_CL!#|8HSF8B@NAvMmMqAxZvb+%lBDL z5!JfQno0VSC6yHM9V-%;O>VN7N&O10EW6lls8m0vnaT6zg?>30Grh9^N&JjYA* zNMQxR-4m2WfZ~z}QrEJ{z~VGp%Vmj|TP5*NL-_gJJ&+rx!Rg4bFyNXE>^th<-jS%mCV#KmN0`0x z0V>p=JZZrD5*2aK*=646thjmx;=3pz(Ws^J;AwrkFb*?737paVjeKD6P4EnEx3iJQ zwF%EH5@7ra-Jr)L*V*AtuFQ!+iJ{1NiODRcuJV8e_xxR{?Q=q0EPZ6~I9A*A$UHYi z+U7Ji#j=sNDvd%6`zFeW1liGt(c}XZ&1GwFt1a7wm z>~;RR@61o}B3)mmG(Fz>dbmBjNoSDt5(WQTHreAQk^hA(lY zSU?N@^F$HvNm)#%{PtjmI#H!De9<5S#pV{X$umLTHuOASUw2HSL`0BI&vzsz#aBc> z^mH8dTeUn9QogepTi$3(?;1lWEO7R$Z%b2ufG5Q}@zOfEr3w2BkuFZU%M_IXr9x@O z_JS6~{E5qyJJmvd^loOOhkxYcWaU+0=LLM@Q!d~~AFAWEB@=PQ0s~0SniG{mY29yx2MtALU52bw^k(91j>sC_R8hJCNR><1CjFW z2qmzXz@chzLjY{K?XD27KVJ4XZrQ{8LFLqebd$;VA%9wCyi7 zh#q1U9iJbnA==9$0cZOLRpI-!0WtPB_(v~4*P_`z3DwV~tP-t%6P3J~G>*^+Aa06Y3sdTM-Wx2i~G6R%{pl60wYG)ae+XQfIPR`}HPCnpL zEtm%Z`69n*X215tWf#T7?H|u+&6UmV#S08bky?_O1!k3sL=MS2FL%RrbC9r9$k zv9pZwhND?PG$iEzPJ*R{x_~h117H1C`BYjWP)%_0au!Z1I-w7 zzS3ganUei{)6as_{>5(>TuQyJ6(vYUWpM&61vE7s1ksw*wR1!T;ni3n%4 zv9Crqxsn(0r9*N-YpV4VIQp8`Yo46dqsIV7VS%w1N%rc$6ZH-ZgtV^jF46hRe5Il# z_@1Orw5k(@Sh_OuE42e7gB7W0zkeo=I@I`K8d(K7e)+OaMMuhaO ztb)KF`x0ykpydhDncol!E+;qnj7CyQu4$9SY6>Ok;<51aCjk6)7Pd6IKngw;EK-6;DwS42%4df>K9FqFM z#}x0|IXBk2RfM09JI_*2ZSG4xQkI&g-(UR`g&m@fCGl*K%Hr$4`^H2|ph&phoKRYPZ3~s4eH1mmp_eRi z%u)I+F}%5^!qO~@4t>Dt-I99t#at%S5Wl{Ad-O6pOzd~$-&8bbhy35sscG}=DZbAS z4=Io|E_QkBu$m~#UZ(K9J2iK}l)y$jym(WD6VsSp1XeSY&%fb-L$C3l6jn6Z+Grjj z@EoYW=DQU>D-f=ZqeXu*$T0bs&+*r7JBt~Zk%{OPc*qpUAy9Vjo)@8tc?4r5Vy7z zI?U;r?n^j4X}JpfwMCT@W!#;Cige-Gij!H2Yh<+%JfbdXiS~H_hS=ODA};Rptbutn zEss7^|J+z{+2qSss^(z=kaZ!2QaN+&5ie)S6XD=1aUyS@L&x8RVgN8d>B0d!LE)S_N(ioe0c=_o&Y=9 z!PdC5;Q&#;r@2rx|5~{Z%i6Df1jLCwEN8IgCg?cJAn~JPao`34kZ6|QiPETNLhof@Vg9()^Qac?X z$0}R{=`F|$kOT1TfjG&Xj=NQ+#8g1XtK)105#N=LuTa>#tn3eKsTY5&?nSahFd{aW zV^iOq5wwg}?=7ptzTaB?C>QOAZq)Lwea<7Cwm1!!C%cW*7~Sg(F-dj_*tErY>0=n_ z?CWGq3+uRZlBrN}DZk&!H~_j|&e^y+TykZ4Vr;aN3?>+d0j>5U_;Gm98;P$Hz#^^A z$x5J10k$&I%;xngcYg{o*3c`7B@)SEt@hnya9A)BcMygkZTYvqnB@A6LmP=9XWw?Z^BxU&QG&D)k zW?h~orm6XL8>l5*ex@)qt;}8S!8UH%&-YaDytz)jKQ)IJ`s-f{k0hzQd0yy=s4j;w z&VUrw-R~%4CqA@})?|EigwrZdVM5eurLx@`8Hm;~YL_T*NMuy-j-b~>)+$FxBiG#@ z)%~MUHD~`#;oZAo6uHnb5?_6nfwPmO%8AlG&UA1MNF`tgwi{0WZ;a2#)5>d6yG#3E z*u-DVqsU8KCDwUMz{z6Cwf%|nd*xXfemKnXyr3lbdwBb#?o@zKo+_HLHk)jNo9ujm zbex^wB*XT%I5**kJUo{*vK#B=8mYZmj<1zolSw3!o0B^y)1?_)>ny{xKUFTt&t|E) ztBd`Ct~zj7Ev0-MVAiNNB2JpW`SESJEa?qKE$#b%Kbl8PJ`WcH8tS>&GXfUB;5Q?< zBRD@jaeM7^9?vjlJ4YKnuh`s;wod13O;!_ZI(99H#meVMRV#eu_SpYhL4H)Dy0_)J z#Nc!_I$tb2GFKs8Ek*v0)}cAEU(2|7)x>21L=<+~*Hoj_ve4&t*w!u`YdV+vR`Pulm{(m^6271+0&5nNAMl-+Uz#eb>z@b36QydWe;6$vkmX^M90hEGn zc4VTWbU2X)XVz}+6UY4RNm{6VN}1L?I?dZdZ4Nv<$)7abrN@?>uPGT>^^^RHq`;2% z<07?;ck>4NPc7>vme7$h^J^pE$2stP^V9m}&$%+MpzZFM#}lj1jpbk~7%K4Xn&;5! zt^f1$hiLXiIPl~Be0}Qt?)9^?)BAI1^Udw$q};vR<8x|L(dOml^hdWhP)%)IcS^IE z>s?!fo;$Q);!YyF!qG8JLv}Q6YXVDc(phOxv0hbaKZWvdfVs`_|`h9eg!=fa4~HW3!6XOGXW zbe3DbI3JlJ*NrDmx4LmgS!e-{FU0rRH6W6^$}5|=k(XfM$A3);oEo7T9K$+D@f~g3 z^+IrN5`dl9gXDUeViWJXQXC}xu}?|gGZrnH%UwaEXt!4}QNcACc>u3fm1@h zLu92PHU@6p@KJGY*Dx_Gyo04;aOGx71g(2Tk8#NzXXi&i3lLl~#2JF-bW=$FExHA^Sr|>bzd9)}KI_0P({)AjTjS)C+|)`DR%I!P^eWcx>`8(Ba_+u(ufO%b zmJ9I8GKcWi3J&)Ic-wT1;5KldZS3=_jqWxG9pJVS%(z9no#3~Ow3JL9=9xK|0{Ti6gt)6N9k)N?Y_jRcs!ZjHPqYEX+7=iEnt(~lznyGA{sVazM8Q?I## zmvvX4^jlF64)q<E&J|sixy*6| zGRI~c>hhL1XeS|a3Ul;bK~MJ_L_!6S9k7y5yj z?<@REdC&@;EAf%Qm_}T-Z~7K}^Gy?}j2?PKyfA~X7QE4B<6Q)nsni_!4(Zg^j;l1K zZUL~O*NhI#xpojMpC-+YGWu?Wo1Z(NZqfa5joSS(mi_s1&1%1zd)l zPXO|V&xUTUbA8Xb+lxHqkRrdW*fJvZ>+mg1a5GXS{dfi9SXf4nfD5gJZYo^C3cvi* z3%Q>HZ}UY9dP#kVgvpJJ>3~lkf5P@d>V*_^-7AzFc@~z#I;43hA;&X(CP&&|%6Pbm zH6E6=>V_U)mxB_-VNd#-U`r93onsh=WXBvf7i!I7mUR@(cd}J+{0!Q2H{VZye(#~x zU0#n9L%{C0`$bk#zgHkI^<&%p^ZwWDqLFgVn!D&;+rmB3j`tp3O*uQ&c<<3!TyA)t z!ulC;jo^8;TTKNzCLl2Csj68=It@E;Y$GI4+$vG3G;fo%fWSYqbCw?_F7)-MrnQ+; z2;b4hkNEe4rTkQ)ac}C($HZFk{j+twFq4{$8Q_jo#m(kC{7I~H*tI`xpeO1ek8A9f z$;Rs!ZquA~oc)98d{4V>M{||_?laR~{PtTxGk%fAA3qpT?^2B0ge!0&o4jXm@VkG^L;z6y2hU~*#&R1$nmLhiP5gBkxccC1h&lcv z{+>bqTn{^@IpmDO3S4KZ2-%&*%ikBa;1Se z-%b_Gk1$eTuJVU+gF8VVcr?aou)hv?C=CrTJ!CpPvN7WO6z3J3nRk_MlHkUjp>$vs zB}oxuW@57RN5g|KiBMD}?K)ud`16?rSlo~I`t>Y`R`gbh0xCX`&?xDG@RLamGOWuCXbHz6v2(evToW5A+<&D+u)iAoIT%;(sEo#k z+=bvwA7r&KjIJI>OND9~iK}R_j#pR&0oX8ID495(&Su=|BY-AK0g;1fo9n_2uFMW zgz7n6ubpC4wJ{bqDfdv(wj{w?fJRF#MdhRJ5o!IUSQwqdrlKWoLRJ~rr!&M)gZq#7 zww>sQv_~h)J`Ly->p(?-1iBJqO$sQjiv!PgMa7OlM~`-*uUY8EH#UOVP66#ImIlhW zSoZRleZ|KtbZZ{V(B`w!DlH?$h}W9pJ6ElU2=NeipaNV3_Gxay23Kw%An5s$Vl};p z(AgostyTu~Er9vU8>lSx9WWA-U^T%MZEK2~*c$icA|gQA6F&p#(uJX-ye;JNiCebJ*m*u**4_b)zD%eg|{U^JJt$ zvPp0S6jA*}) zu^?_jPL*U_4X1`tBFOx@z$n?&ie=cWuUX;CM#Nl4zBD%MbJaWWBRY!x?=_^cu2!3 zOQ7RFJ)bnx@y4h4SEYh~x*ZaZ8>qL$zLc;D14j~~40{?KQ@<3qaGfd*SbJvjGi7Wg zNeb=agmj$$>7xsF)yCVO4-J;9$~>wL&Qm48;WF9l0{oPoB$y%~Q}m%Q>SonSoY0y>4Bw zGh)Hf-IhJ5R?Ocuz$vE5nwBNy2oVm*{B^`=r@_*+VU&I@Cz4e@wRqP zDU65tYsh2=83NKW@`L2~FLAF%3jut|h;dhJ$vh$2DI!={6ZgScJ6=-x&dB<}gI?D} zi*Z*_Yik6WfH#9$+j6{#0`-{f+0YY9y()%!y;Ia#2ze|^wV_}Tb_Ps@UhnY@^CffW ztXQBy$1#|Jj#E%}8uSY|vIDqeSPwH8TGyYr;Oa>XQ|1y(EAE=rY5M8E1pNWBw#Lo9 z>l79dW8gFw#E>vamMWlJ>Rb2z|?dghn&z(Z{UD=;e8 zW`MJcN?d`ZwxTWTGC8bW=MMqfpE5d_cG?Sy8_HIYp@H!wuYHDOtoV=ZDS zG3#odg|g|>=o4|uf*1Gn4R3AFhgyG>x<*W!hM})bKLaXU5cj8Xn==ptuBi26I$nS3 z2)Q6uxQ2FqUj|Hnz}j&Q4~K`XoZQcGmx3zV;>h_TmJ6Q=^6y%eT!Agn!7-vy0Cy4j zyAqA{E3{&E%6Ad5SzS_q+inHXRwk>%%LGOHs;srYd~+!z5>J@DA^4mOMj}|Ns?VLL zm;szBBr z6%J1rdD1H4!39;sey3lo$K_WXI;Jj=S*YW@Uo`LPR>PK8kH4d1Y0$4<*N<_?=tLLR zQLl@kW4TGSx;LPoQ7kB8)P+jXO8Eh6|dM%iegC?m2@^DI){O?D*-lXU<0_& zvP~287hG)roNwG--EM?t0i|+I%xz)YnoaKvkOQ7BB+&<70qI} zkjJ#5X}s-obdAByJu7rjqzoUP{V%$%I-shgi!b*+K^l})R752OUWW~eiWsOUD57Eq zDt3#m9c$~TtGjjw*xiaP*kE_JYhZo9i3bmNzkifBcjnCLIdkUBz3x)I{raq7zu_ZP zts6g6JtkM@EkEqeS+mb~>UL}!l%`%B96ix%*XX|wt{K~7 z_sz5AH!k^FF4N=mwX1(8J}75%By;5QgN`>RUT=4`Ytw;KTl_v?+2xd(r*m&S9la&& zdY1M1W_yPJ{{8$)`zZ~M9-cDikGiEN^>{ zxdVG%J=$a7-mH$5h8{i;cJWr#ZzFDcT#MGW*j_98-tr$CFHT7NGL1xe9^M$%rTX<& zBU93v9Cu&TCE-ekMR#khxVSrFSi3sj_p6-==~(hZ&*IPaY`N;a`Squ`lm`(NruJWc zu~+HT-Ri}C4ckwoc07^%W^`&q?H32%PP-ELJZ0MkhtbDUG>HS+#WwhmGN{+V12dYI z`sUR$eE;=UgKv%))9}TxP2XqCUgUeix4mK3^6Ps|En6h0Tc%ANQ$ZcC{(Wdb!-3Z8 zOov+^?%C7t&cRRL5mlxzR`RsTiDU#yL}GkbN3m}}=B^nLC3ZeU}t z?U7$gZNDB~?%}m_?dz0l;J2^n^@o~k8~0y7`fShaliytOCfzx)W=oq+y6c0Q^jn)c z@#v;Ejnme-1T@=o`edgagGTlWF+H8V@4d}{Pqi+kq`okQ%-a0^=%Ka8dpnsrUq7M0 zGPrWu>*ViW8`hckA}FU}sZski6OUI{^_`i#|4_pwPgd26xDcOG&%^1|y-jk5q3vFu z+8(@rL}mY3-&ZW|m%eJxw`-GU)aiY=c+tqs{i|+?xP7a?opX>=P2Ej=E|-Km40Xb( zM~8(vQ_ko+m%ZJFI<&Mt>{DZcX3 zcU;+k#ful z_YE45Fiz2OP4wN@)_(f6t6HplckF^8eS?3)+Iw>I_HQiNy~);)Z6!zbF4`sb{*pBB zfKlTv`!0N3uFVWvOAIm1^w!eWUa+@z$~#M_Z1Q{&-t&@`RJq$)5`i~XO3|uC1$UEw6Tg$w`RkZG%jM7dUejakVE~_e=D-UYOaTCmxe2@x3gRE zWBCHVIe#xtu#?svIh6KnR$TMx&ka{!CGQ{T(zmbcisnmZjvQIU@$|LDGgsViW3XR5 zcf{n={U*=-dPfs#U$4>D&?wLCD&OYzqu)7XCNx`rGOkS17Ixanp{>1NPY$ir<<#c7 zYqFYOP~_$|+WF;HQ{&2ntk{v$$}|nFnyi^P|5>Te3)^p85s=bj@sq5BBm0(3d(?c$ z;m>p8LaRn>pLy3?zS(cxZ)@HeH^pLPWN@&me_~O`j#s_j2)x7ZiL%#ua?Go?w zsawzK;Zpow*rh}Deb+B+td}!;-_Jg6)+hAZf5Y=@ZhfB?J=VTZehyqYbok6SPcmz} z?JQmY>zdqhZ_`NJqA4S)4;ty;GjT=LQ@v(JecX9sef7L0UVGoYz3CUy#V757+vK%* zHjQhx*x7aZMdQ3r-hcOWKK^-1u`cI#>YCrKTy)Q0shLwUma20aCqEs~zuTww^F8C! zT$YY#@bt}-_}~Q)}(dBN?wkP*c3C+_jv^uj3!5z1_F-$dxs_Gwv+d_j!a<_c?=x4_vio z{3@4TBkE+{?!RDj#V<|guJ@O!`IX$abohqUJ>@Db`hH{6id_%py z4{dpJce?+#yM3S5dG7c3kg(9owWc@QI$^2x=HDA8fAvmoaldWMnX7Vx7=8Kk@02^D zsvoZFx46RddYX}Gv%Ypc{@BhZEIZ+D_UzTawZD^O6Zj~$L#dsn-dO`~%y?XD**nLa zh0o&l?{K{tUg2KJ?A(QQn)-ZO@W<+#jc#rznVt8l`OD-*osIDqZvANL<}y5N&&C*! zpem1tt=Am#p5>wU-?=z@d8#JlaGA|XcTbF}m#ef*JJRUEv+6#*e%8r?zZiWYSIB_P>;Y^pA*-gDJ{r}3@+-&wYr80c!+LSFZF9SMGAJym3 z;O_ySx0NtWzS;g({1v;F_0EisNuAl)V>7<9DIe;*=yb>VsiS5Mu(O|1WoAY~R@aIi z{c2p=)-o%t>+Tw>T-LP8>bf^2pq%&fB8yf=1};wCxAT*kIszfoZca}Tz25P=fC~4dr9Q+r4gNpKoQk=532gU5?zw^rr#3w>ErH7C-2_uNS*H7)%64LYY@F=$st=aDVfoyomc+qAZJ z_btD*T$kAWeUWYxDm6+;s&RVBgb?P&9`^0)v-09J&xW?ai@&b9FNIbhpB-vwbVu8!uCEloxKi38+}78*56_&rbNi6R z+wSc;9-v&>veVViEgbAOrgWNO({f*Uw;8djn2K+@x2w2y+x3GjFWlKhTzde=Yl(RdW6>iLV<)`WN zaB^z=tGl`FBA=ggFMfF6{nKgHz86nwy=}|M>VbB32Q*Lky>8|2+0C29MHo)JpT4cE z&&Uaf8va}oGN|=MIq}M#T9?}Pa*Mq^KD6`HO@9wLyQN~_n-z^7hkWh#W9!=A!%y~^ zpLu++d^F3hqwK6MC9LVwhl-%W6V2cj!qf0DYK4Ev` zlj^hq4QqX$cCTvW(Az$F?k7Jyk9~1y*AA84`{Ny-wqClqeBtY{LRaxyDwY47y?H~@`H}0_ zW!LW5HZez&dDj2XOT~uShAe4s^PZ0T`aL~*vS;F@IrA&wbM%{#|Q>rI4;%m*mwLj~9-hi>=2R5*MT-CU5Zc?mD`Er!wjEY< z_v~pu)_3=b{&5Yy8}C(}I@{sRq9xzo4*J=>d$FIs_mt_+4n>bIUn6AQQPQ#NiFyq? zHe22(rQzqCt@gY8<0HJPx%99O>l*Xrgibwe>$suo$0QbQ@z<_nL-yvZ+BYz(X0H)` zbG4tpyZrO{`BX>ep|jKb9$B9@yXxm8kG~X?M!a{vck8iTQkkBoj+{%23Yd9V?$+Ya ziuI>YE_0gox^0KY8xJ3ybLdK&xvAy4B@EiTFnP^`-WSgle|%&7D2JSJofijeuD>#7 z>Xq|@F5IuUrpG(qrMIFpS1&6*?ntR2bslYsyFTOhBcB&7>3iENWoqyDaZh%3KKrrs z`-vH8zGd6kI8?c7>vTGM?BGtL|8{lt%l)L-bK-FO5!;k^f-8;ss!-i3UTUuM`K95; z;;yf1mkGAtS0yB7LeVktr%w2l-#mG8R8ZvkieHC+9ers=%SpcX4!UgYGU#iLTMPTj z?d-p-3^T=cF4Gwjv7C*1}mf=4JJepm(bhqylYc9EeJw2^azipGQKTfXSxK?V6 zb)T@OtKTQ=IJVC}I&*kMn?!X^?JijlJ1oBK+3)WXcU`=nl-hcI_}8e?BRx*|pUCKH z=-amIp8H>tKjnp7-MOcZ<2-G-$)D0b?z(*S^Oy6hPCV`Fe5K9wS0Q`j@0_jlIpsmz z%Yg|+)}5L-(BQb`O0^>$@9**GofftBWz)pr&Li?FtlQ<^`%b9(Xu}n2qYpPDK6PLF zFWUR{(AtQUv~^lITiNs$<(kh zcOQ4nE?wjIRcp7EFJV}4;!d4rsR`;-e6_OGKeolZJI?REbo%(!4ZrMs`D6b3AuWbX zUp;42THxn^`de>|J9xNcMy;U0W$~@2w=Zu`l17)R7S-~R`#&Eu8~9XmJ)JkJw8Cw1 zbfo&v&h{S<_Of5rIAumqnSZ=StaBKBDC1Q2h57nHD{ju!r)zga$+MdH_xj5{{qv2* z)gJ!Y;78T1C#nv5x%KwC*$1qBs)hc1RD9vwQ+C?0U8#2$Oid$Gd+y7sH~L2V=WXMw zt;@>08uVf!ah#b^b7{-nk4+D|heU1bm)m#6s=vd(Z@zS4j`N9YiyLqIIK0M@sifP} z507VeuUe+rOS=hiDTCI`{Wz*d#d21zEgi>AsMQU>w~wjOyzJpt*eLhJ$wBvh}8U1S4 zo%EU=?m6_m7JZ@1z4e)oV=hL=G+8~oPDb?=_O05T+d5+W8yS4Mo#C6{VX zSY%l9hs%<&?V42D9#Bf(vi$W=`}H>C=1vL9ZWY-qxpUm5zg8xdbc!UIZl9&39z~xH z?PPpW>S@Kte;)Clwf}xv`jHW{^`9=JZtK6|(M;LzQ{c6im-?-Z{nL1BuzTjdNt2%Z zog30`VbgaR4Km}0_vqo>`&pNyi7k!y{Ho?y>4qxC#cev87pcGXw0>xLZ*u5CdQSP` zMQ5LCH>-YFWo3($HE>%GRc*}XO|<@tw<&3mJ)M-2Yj(fiX+tE$#7+U-c4Bpr6MGLW*DEzT`$G zHc~i{b&I94Bx{)LOd?lH#YpH9$&qAylmbchg_66iLG7#bZQ`pok$}IYMb5qkCHrkq z(f^W2_!23Ey!l&lveJ+>OQbR+(n|Ivz5%kcwLwd}kbU_*bi}w+Dovi#`DhOpgP!)N zR?V(s&knuXb+aQgYAMRjod!(C(T;q3|mY%Ry2l8&I6wZI1yeB!3naiXw^Ycr~q|xTT zyDyh&n*To844gW*TpDO@XtAQ;VfqR{(XT{?Y&B>WTho>tE9R3FJd9+ z_^}GJX~_&qQ?u357<2o})l!tXeefRHo-|$~4K+W!v!>voX{|KQ+A>};Da6LKd@awnhGOMWD^rox%i zIemlVL|Uw;bXr1EamMI1No3J_$>d>T3R76LdL0=;nZ_72V4YO6qOVHHw82-U;;N`p zab~Ghj9W$X7LcWNk#lKxvkPqnR57&+J<)#EqcigAofrdIZRTCw!j?NU)~mAOyQJZ4uG0)qDmvE)-bA*$fk6#HY-Bm zT0(7pBKV+Ta`she^dz>8!a(M1lavr#_EyZ}xb6k={F`N)#^ZY$6Z0QiLHv zS*2By9|IJg0916R)Wn0$NU1a_Ek)kg8w{iBNS5rBni1a}kkiUt;4>`8iQL@@LrSG> z&3D0Fv7ZNbKyvafNP*7drP2wG=!6C6*i1>}<}Ro*e9>-T#56<4eetN>XxEc$+MZfO zb|XD@OAc;K2);^7Vd_ZPoe+J4J-}hXE=<~cr=%oH_5jU_yYW-87dV(9*xTv_9!aFq zUa1ku0#q`0FBGi*KH3lDU{=?IlAEKd5C_Um5gf4Aa|FHif&Dsi=z!z~%{jZ*jK7}Y zNOtU_h*R!V*)MsJ)6-;os$kox;!y+8^L1j$eyJXm@Wp;9mUP(%Tr=FCQ|izWNZTezqSzYi2D4N1w2^$_LQa><~yw+bIfqcPEa=z*PH8C`)VlSF22jgu^F) zW=ggW8VkK7Z|fEolQ>({~$)&DVZMnYD`Jw^GW#H1j>RIZNR7{v@084@-&9mIRQX@1|ry@ z{y_|PS8_ejsx6RKlO;VB;T-FibkxuzkOnl!#>psFJgP!Qc(apID>q-Yk_%g{+IrDrfQR)M+qv z{aHNoIRhrVI4=d3w3t?{;?}R`i%t@Gdlq`*@=UUk)hZ)dLRZXX=V1F4&q?kM>H;-Y z6ITt)j*?Lro=_paXeE)S=L9_BcOGo}`z(<7^E@0{x%1%c8~U?l7Wlz9dpa9!HO_&C zh^C4lI>JMds8;L9^mAB^R%T&Xc_=CwoTRWP|71bOjORgK-E1kCK5(-~XTE6ajATZ( zRE4#Y+vfo>>b&53X-o3O+N@R!okf@)23&;dWuh5EyLmy<1Y6Fj;To#e@Rdj{)-$z+FW(0)A=&!3+PsPyt_b!^Y7KEc3|OX3!2RuI zESbE)QE#%8>KnSyQ>m7)L|MxnyjsgpCua`>Me3j;jAk7bViz%;ng>|E&>^B8>v#+r2*k)D<_HTf#|z;tZ(Rd_%(`AQooSR1vL87+yvCPh11#AHyr#!ulg zyX8WRTHkqv4$m!ssbgcYRU4HnHFC6+4{%DB0|B0O@gQZcOV&i61AWk5m%=18 zm$kvVJ|PFQj=2u?owOHtUAiuX&}UXRq*7Qg%iNGEi>~gZ_YJyY=R(2QYD^VcboC(4 zHzjLCGg#Jd3-+;@*%YS!u)(i4B^8aD=$t371IFf?kX9iW$)yy~~T=W$t!j=~H8$F);_TQ})>vu#XJ5DTVv^s`Wwvd4z!9LgDl# zGV3-ddvlZW-%1W6d+t)_atlb#xr2Fo=V4yD1VR~<(`0;b>#pPtbG>^D?Z&$xgQ*J} zWxNelG?0kR5Mzz2l1)$n9%}OjSuD|NzU}o@^QD@Mx+}ygVU^7O4A^Thr=&LWZMefd zAQgxulRX9l^1JoC2SK3Q;CpamY+%kE;C|&Egc@=eL?4Y|oFb~A0*okC5z=~YrKK}B02=7V} zp!0Au$C8`;P;__HSn4M!8zd}}ym$yt*|LpnFClqA6AJmHHGCx5Atq|^$UNh&2cT^G zBP>#O5Am1HV?i05st6ghaH{K{2qiQFlC(OK_ynGoVkc=0#D(_AC(RS1xi)C^h1TPY zOqfc(I39tQRw;^bS)){PTmJe8Hluh77m^RlAyFd&3oSx}>v#S`A=4jAZJ>}Q;n_?) z6i}N4%K-fLQz&H1Cjf4GhQMtd{j1$;7Ek^0TJo|=A|syxFnqr)6p^_Vwue_emsDiW zGv2OxX@={YVZpvJ^ML={v7%O+&)kLI`abD zW)JLNQrkBWkCzY(Yr*o05b-6D#e!&0j=Th1`oKO>BRsrbNt|Bs?(U@53&2Zx1AaAz6g(oyn%-9cnLdGld?19K$7uX@&MPx!lBnE zk%%`^C9)aKq|Ga!_52NWw(lfo()t}@f^^yz{|Rl_m)O#NSd%qsu_i-kA#eF`cfLei zd=B|iMmkzD(nNLv$FjZ}vFX-`06`-H1P$L~Cy`-qIg5*u?QelmjW?j2x;V1!t>g(( z&(h}%LUH1<#8uR^^;dXrS z_ca=mNYrOYeOlsguaiG+OPV?4>J2yC?` ze3R;soIG^D@h!i*JMsArccLc#-$iHOp25a`wRwY@8xH6k4#JEvW3S^^T z;*wFxV_)#}XVPZyia@z(ocCwRc z+I_uUzO?v^lF3L$7DcZH_HZJUBtES>$t?Y6U0py0* zV5)U?_~$f5gC3rcZw|0gWHmx%tx{|ys@sD<>&l}CWaMJaLk;q`BPd0H>;zvyg+wmc z%jI2=AF#wv$u=t_%mKz}By}8QBvvab!X%_e50#YNXi~T#g~I^zY(AOlgocA9ASacY z^mYb12OPlQdo(>x=aZ1kXU$09Ie_Izd$0qFqOw*Da7fgO*hHmEBDX2L*PgOX34Tn# z_Fh_kRN$*svG9OYbb%q!NwGN^<&C|}B1g9gV)#ub46jtoj4~4UK-rDVUnJQBWh)xE&?6#qe_(9RL*R_yma9z92%N~5=g3U3~BxWd{fFcZ8Yl$1N8ZHM^(H0_~8@N{N&b1=g(TZS8D}o&@ zkDii9>Ec2t@VJaWXI(&G?@NL}^1ux$P7f0$AbIyMWbk-DN|^99@SD9T6eXaRbRp**JXlHrFFYeGt&P3MF4ReV&2}r)!~j;{Oae=QGpCxtVbv`m2Nlw75%g%a+?l@c=DKZ5A~euJ zmdniX0rMCf*4EMs$TabWhx!-CL{y~ZOGXk=mK4&V(TIwg%6cyt$c&P5xP+7kZNb*% zb_u~Wx{a01?-JwW1aNgzQPTS!B6d=1rNyVYxqf(DNVOJfe^ z`Scp@;?DX29XHtaV~?dTgqagMS|3x$bO_m$NnzwiAj0+*DF{$}gFr3q zDw#B7SqQX;>6D4|4gidRVEj|&zHIHNz2W9ys0WTk(J6I(jyph9@$7PB5O_D@t022isX(~oW8_vv z*+as<`C~=7J7T@N204-}4~3be1cQ(dp>kdF2TBsC`^?@Y2g_?)~~NNzavDApj;FbgX0PTGb5$|03pj!aj})($)xqx1q^#znwWVPDALfmu1=}HgLXN803HB@p@cjl?sVyzP;7dnJmuN%rC zG;C#)RSv^s>8oVxd}b9()QQ6|F_|xp8`N@RGBOOZXHgq~+mI~0ewHj%v!I)S!m&~m zJ-l}y?KJZ80{+BkE%-A*E4#ut7H9$RtP*`cY2~(Nb}!Ij{WKcL9i6Kg90lPb+k@Pp1MLCW<(?Wy#8|7sMfRjuGfXMpKo8=of}h__=)a;WghZz-rsL;1YyeNOkcjG- zgX)weFvPPAm{8K1q znO;MVCG)Go8^5e!HgLzLrRS@8wilzwdI=R?lLKqER2L7d0riu9E_BMC7qVMh?Gl^Eww=c zrHQ!uz>;s*K!<=@a&0mw0)Gvu1*Exfc#Oj*V3?4vQNj)Ip(i2$#3xFwZFwMz1EDQK zzOoK;E{MXMK9OjmDiT_Nb)rsqcAbuUbe#x^bfSzyhYFF#U{2&0_%0Qtn@XJ0LHXo{ z@q9tSENo>^A>M9Y2N){rV1Fwj>8mskwICXf$|YL1abRl*BMD1>KF^rJH?IpE=}>Z} zE*RIN7F3m$bZ~C)poS0SEAW>(a%H{^X&Z%6EdNAl^x!KM?V6|)tCbGtK=4!*IWb$J z{!NUCiF6`(QXy)oQctiOwl||8%q=Vi60(|)Xq}lGKbm4FA$e4ono2QdDQ}7a`#23e zBH{yBR6%an0}UCSpa-QIfZos1kUpcK0Cu8IL?Swa-hzfd>sru|-IOV=NVw=kP?fO_83|kd{qB0Mi*B<1qFihAFHwtD2hm zT{aF*gd=UPhQ!j&qYm=8DfoTpcc7dVhbSPor5WV{*oiukv(lLi7AQwH{x`~^c1OqO z!RmaVCimLzB2Ltay_Ze|fI4v^s}ljSPDGnJq|8Uf$ttcfo0~yQ>}>dAGfYZ7x{Z#X zfssMYzztg2AmP+#)Nt7yBB<9AZNAAY!l6y{7}=g&kHgrswn!E5g@f`fQ7`h5dR`!t zMD{edfX5iqwK){ARJEx^gx7Qlhktx~O!8CZ-auUjB#VIZF^#?n({ z(ku}R3KAp^WK|*%FEq$jq^)aNC5M4eHoG?2gh-CF^RC@LnJR_@HA{kk1kfK-#5qs%*>{Unr$*XBt6rpe_ zrWZL+y(r0o=vd8LZY!wT+ve~(Ws-oXt`%fUwXC?FXR9p4i4u&KiU3)U>I25zgLFXu z*3b^_6P+xNuJtT)707$H0`(@6+!}t<_Y!if`5;&w_^2c-Yg8x7@q`=KPLasciwYz? z-(KO^x=p^8YWQ-391IR7a5^Vp@6JeBOItd($yZa}(IHVUYKl-$MqVUyb~|$*gH}qY z%WESr3A4mR6c*`4K1|QEQHA)-igmfBB1gqERjVU^Cc`aq-Z*Lv7M$d{ zPlEh)oYdhRL0F}Zf-qTchGLGikh9p)r2vX+CveuvN%q(33(>)SnqDOB^kOHk7mi%d zQ*cSdt8+f9k*I<{Bt>bh|Det?E#_gS@|0G+Wp{!Xresk(X+LmU#Edk#<3cfFu3JFa z*BMkyptv!IX^EN$IrSp#rRO0h>DVQo#X8|I!QE0_1z-~04O=jr9VT=~3uiFxM;RlaJQx}1lOX(zhVm64jrvlRIF`0kjfNY8xi z(02yfZTXhT0Ml=oVn!|>&RfZW>`sxD5+YCrIUxn`+*5vq;?A=-2FndDfKcxv>&?)9 zrT~NP-TsqQ9s=ok?Xs_4gqnI$_N3=ADp}P-kSYNtjpta+0debv<>+${EJvMs0Xo+u z-oYzT&ogSi29u?0;`zLMFt|kENLJIqH3q__Po-kx#cWP=rjfgR+Kf0AFPo#f&km0?t%Vup? zdP5E$dO;3s1+-8b;@=0}`dDk=?J`MrsVDMqdT}bD7eyC(UStV3#8bq2vCY!!xWk3i z*tSbA5|nzLh|`n0eE=C;Do4im0j-?}gH{%Q=|$A5>GW`pN z%&UqavnXj? zu)}RIZDk>ynGT+a!}TTuaUB9pV-8|nf7uiKZ9N3}q@*FhX73P`e^M?{w8^(2I3!jQ z>!ETbO1CFHG~G0mqBl&gKoW*xz)a_Smmo&j=U*^F5Z7QBdYh+0DF}w(@Q$8l$_7+6 zFpOh{L8Wbm{Q}3sojWL%%JNVeZ0f5BW5_tFjFut9lBZIDL2n^_gGdS)M5JdBh3^It z@fk#PO?m(4L`8r<_tplnKQV}K7HBeiF!0mMB=T%HNMf;#0Ywswg1N&%L4y%|J#Z(e zuy7*Fhnoqa-M~%{J3fJm)|`fn0uXw!QQ|P%!Ik>MAr=<*SyCYmOAVsb%)reWx8u?Z z(BNB5YzS|qF}na#e!Q@V>3{(>2~?h*A|l2D+2*kyix`#uB>qnqel99Q++F422Mmz)*!+SP7k&S%`B?l^Vts z{=1nYczS3I@VJ2yq{>L)>cTAXFqfo>_|?FDn}wf;o2ThZE+*8IGJvcC*I&>UbI6G;5>S)MQ)GuieBV0B2 zm&9ZMb(1pSUp}eq7}?Xs*C2vI0}m}p=vcG!H=v54DfmUpEy$#?KsIeG_`uFj>GTrs z;6{AL$#(R9Sl~Dunqi1LJ*mG-v7~xMk|qMk;BjC&&MjxajWW1yj)?{lui>g%5(yoT zygYm2PC~|G9#-;Bk=9u9TdWlZk-{{H@Y5hdKm!jX5sQw;^lS+*==gdyY&@3LYZD+u zhLu%k2=*Lp)6zCh5bNqL8;}_+GXc-XO@Jls9#8R~0F+)#5~D#$Dpk-^6JTGc0|=D( zEbjIOv3RL)F7wAE@B^dWC7p_7Q-mlv)hx*oOP)c5jRp~Q8bqejzyq*C>cpzoC}j|A zwMwxpXNjc6NcdEN3kCr|adM0H$K`6c0YrSPDQqg5p8p}FWS*;F?w-p8LN|U$fB#* z8N>DPcCiICh)M;6C=D=(aGIislSMrlJ55%C`MzLap^JkCa`ymy2a9bCqR#%zG#n$S zNU7;4GD5+TJqeyG+fi0dKN993+qXNcR~qJ?w@dGe?z0 zAr7Xe_vuieg&Vk-1%eaBb_gE!&VX=BPKRW?W+MKg=bpt3JX2P%7~*USRrxeEOKFo- zC}W?+=ITv#1y>IpKsKv$%25LV>W3X`RDN zEEGFt0gqqc2uZ1M#Ia_M1sr#No3Q^ptS!_XP>552A+lHrw4WsykS%hDSRrrBg?lt( z<4)Gi0t05v6>fpnw=#Ub%>q6j=llmgA{z%st)I&{0ixW=+5`wvhvEXh64Ur)E(Qn9 z%lAxX&KN~3K^Lk_A}E48Vg{Fc2Ps9P_w)7cQsKJBHtp5vQ?C>{sZcNd({tclp4Hq3C z0FkOx!{9d3@wgdh?PKH-DBHpqMHFh}QD_ngS|X;Aji~!uvJmt5EQN7E^_c}XhmEvc5P{x)sYu~@#lf|aho9JXEW*6h4@1PqY->E{ybWW z=xFr{G1#%tU|KZcNhfaNtXBmUcvS3xarPPp5LA^(y)~GB;mZF8@ph5i6&c+iVzU}s z-|B0@jrOYrosfo+{IMFUPv?;JnjrEOy&Nr)p_r;{05*`6Ev);fHTm6f4*eQ0&?5os z!Myrw(f%*yp+eHkJiy06bdlv$J2v7VTFunbDv?zG1BK#0HX^RYP9$)>;18K$Qn-^6 z8$eoijO>rw!}+JGMkH?mmEH*Hy&Ok&0UIzib#^p#d%fq<>u?-vIg-}N zgwR6|HnQZ#f{_{S&{kG3czHeeLq|GVj%4SC^xY9z39f{ZiI~qSChYX${I(D8Tf%X z6)j~v1mn7#VpoXuo51>V!bgel(kQ}9%Ns;S8s?$U9(&`npbEv5*u(EK^ReJe-H1(w zr3l9EG4lgK6jlC|y%;&lAp1KSEk_kr{K0z*Mp4D5mtceTKns}KTaGKN_Ay5>?%+N+ zcPKq>j?(JPfW2mOu^5L%#X{+^SlzYdBg>OB2f*aF`=I;S>zCNiWzcxPJf0jph$j#C z^CwOR=o8#?-Vc?YZ~)RVorhIiJs<};SWaZ2`nBkuftBpgdu4RhgL`>Q`7cyo9O4?q zB5(P&1tW2-gX2(CKrstoX9PnInknOOaPzo?Tc$_9f`b_tVf~9Ev!R z-nXITN(~uw#)9bx>!L{M^RR)MXZholvldK$cot08kdSj=I)=7AXJ&dN$;(6*xG>Y> z!SwQ6?M?jR2i~*AbL^IU_0ltSgo+SSKOw zYJ3S?&&vkl(i>#e|24Eg@7Y-E3ud;fx#p){1WOKQnFVG!tA*xAlB+ppzQelV`z3>c ztj!jDcPKPWcz(wAiWkAx7MIz5@KKHmf7yhWeXP1@!Fe2eN0A0s5E~%|43zNr&r24Z zce@O^)wl{IJ6(og@Oawg0_F#u{}=P86==LkBqvSggAa=|g^3nMLgNu*QH`gskRmo$ z%*^LmMaFzhVU1_!*-Za%L5ylVUNq%IzF#pj&~jv9jo0OvS&w&7(17RfT);w0arYUQ0%?sV(<@6LoI^ZjiX`K2{!4y8rz(P6MGDm<(qzbV zEO>yVmySGtfE@(IjAHNmP%b-nCu*yZx}g{?c?f;G^%&fG_mFZ+bn|({y5S0jlJ%pL z)1rpckFXf#;)XIBdjA8p14ysOyf2y%=|_@zj}fo8d7H4cyGJ{NIKZT5(&z1b`7I3#$vmh z_o-kkBlB|<%UniO0SVYGTNfgMdEES|^+BZiTbzUrd5`H9y``MN03c>Gc7_{eomHdkD(+yrY}|kAR;shy=Yy<)(=YeGh?C=n}f5zc1*5 zyCkNUc$O8Su%;0tf_{Y51E(Rj;OC(xkq?q2k3-T0TJVH)-l8sp0onL|v{9sm8 zo-t#DAoQcxIUqKY{SVfGt{)+pw(lULcgJusRHaf`0>v9mxLa{500Hws=CPzAgysM! zh~J4Esz9rX%rIhqgQMc2AE|Z05f&bX`wtjKH*k@p?N2x(_69#Cc@qeIJM#rNIDHcS z+Og1l)L{opsNY|54MQh=mZM2#9+Y@<5BeTG%tJH5_FrT@P)ZI(moZ=D=sA@TQ(yZc z2RWGv1EUO}z-H*tb3`71?fC}5UCNUKWOOAz^JKk*^CafxhEgULmdU1RiV9@ePuW|d zdHHXYRJ=M+0{u%$D{yb$Kze>fBg%8Fom9$#i(0rZGwKW~iYf0^-@v#d-zl~9Erv>- zVchTom#h1KL+gJHUZQ4$wS4ftA7U__m>P?d%HoANm}>^T+DzfN6h;F06^P-mwStR* zLSbeTYK7NwcKPvt#v+cQB4l!S@e`Mh0wsm>oSKRtyg8wV!p#3Uj}+0^7AmdKq9UE? ze}dh2tQ66tlmc&BG)Qz1NtP6h*^D7GdqJM8dK>rKg$2BrrU)o0Dgu-uIjK^Ll%@(N znWYs9vjo^q)SY+~0sI>hU7)!PcqWqSKlqZ4<=CwMHA(p*=*H!Tf~P##j*B%$Uy;RV zFwb%{Qj`U%UlV%-`icc8KN6Hw`3c?=;D7}NOOL4Pr`#_Dz|siHJLPkq(2OuP09c~S$)W|q zh_qGIB_r$sV4kfa$jK5-T%~7%&VqqMlF5r@fBMb=A(N2lkclX2P>NGG5X}!2R57%i-V3~~TrRxXMl$9$)%Qo;}zH^DAjMJ+PkLA(|d_JEuuPT$p}B84Qhm=`c{ zF(NT31i^;llspuChevXSFTp84Uc%{6Ai_c;E%kq#d%gtl{uqSmvI@5qd>#MKq?YQR z?gR$EbOHBloS7=CoC~>j!B;u7ownrNz5$P+9CFtR}AbD(y$zkU{6ScjlSqK$f<|5tL06AosMQmM@@x%YtA&Fn zdJY+f<)W=8(m1F__`|b6O4eSGl9t4JDRlJFcrW&d8V32`ihO!u(X4@JNJuG#x0B`G zpPC@v6$cG9P;>AgRZ9Xd*}H%pJWt7mfn=R93#_j-NxhQ!E=r^3e9b49reoRTZf1p2cj;6Iu!GTAL`x;4Y#zAex<-U6WL#? zuzn-(q2%$Ex@T$lptZhGj$@^n6}>K9!1^v_6m^|+g{9AKG*jurp0Fc$TBbl8&AtC6 zjwe(cf0S2v6KfApy}7JlhLv*e8-%cb`Ju6cuV4k-El*c+F(5x_wh6|`^?v!BWT{Jc zGOrx032|%p6Kr0L3l*3glmCxTQI)56PE-iRN%T za7P|%(U!5&mGTgQp7>UP^5RXf@f8@inAT@ifYv((;&Mj?e?>5T+StE< z^{4z5(T)~%c91y>1_kHQJ0^gy++}^?FLqHL7Pf?d8DRbE5QVpdQ|6*Ud_kbqigZ1g z8w~n01M=xdh+>Yl@&5IE{qG$N*ogA*qHmF_{1Ob+_pASZ2Ii|i8)zGXZdlvtq)hWY zLow@~p#L-2QuE7&a<0>%EG$}0hi(lPn&JW^EfKcRdirLK8NC$Y^na@&3U_QU3nFSf z+K5wE?g9&eK<@&h=xm;y%vVC--|5`@l>%+V=$3P{m@+?{-4+U=t`CEPIE4M5{vwRT zi5_Kc$-sXJuG0*KvKY^2Vmlxf6=VfAgejUrm#o6Y;z&0O`FFU1|Jxt<9sf;5l~UaRhE&Fi*Ej+Qpmz}v1xcJ@4F%1RxmrN)bU z@`xY(HL&|H1~7_#0zve20t3w9CvGB;DtbU-2G1ekwQ2@3SFfnbwJ=BvX#e2VdcVRD zuOU_$pykyJzrsMF%{+sm3Ss~j$%g14?vHw4_X{Tcl$gGH9dAXeR2T|*s002+E#{^# zK@L$BbY^ldc? z`dAOjA(0qT8Ns3NCV`iEyn(bZqOKZsAlCkckrH`ajORzH_=9N;X9R(+rGV3eg&Z=YbbS;zbNI&uVJ9$xMt%Ivs*LA$|_L_ibsq};$Bq{ zM~|&X)l}e0c-V^kDWqSa8q@_ft8pOaH0?)q zk|rldC1PZc>i-(aoh<4zy{q$)^geaJD){F=w8dQVsuI_QU}$EtFhxdnMJ!p^0M>+h z)rkDLaV*>&b9?tjaj{no`o2JFMtEyN1BIJ6SY$pgx5z2Mw=geG>QW9+kcc%b)-pWi zyI&Q}%+>~UycF7j*hLhEjxUv{L~$pUgSL^7a&!$u9TXt$_d|7h)KCP~DkLy*6$NOS z?Ld^U0+d;nJTF=ZU-H%pw-_kiv9-Z^`i%yp7}%X~NWg^=OTO2|lyXh*ma>3WRa5EN ziAy^4-EL!RakjZ|FpHv5s|#hof(D0z%poNeH-hcS+nR9amQdWycg!u{;-;b>Yfxe+ zGB;FnvSRQ;GvMgjT@g^Lu%e2qH=scHSGXkRl+hww_J4fYfqt(6C&BQbk`eF9qI0m1 zH>B1Eda+Ro7c9rDmA)vB+^wZ3&+PpdCnVnWjL*YxUt=k06ce760>D|E-6tsum-MMf z))7fbkLu_n`kM93DB)2`7p5+MiQpA~NhF~T7|rp<(RM=^yh|O08oXxMnr;Kz!?gvr zzrr%JgI5bCk)L%jX^j>N8@L`72f(WDy4Dp-F7+`C?j-tks=alfrPR27fh&@%_&N`B zAgFAos}t(qiZvB?4&VpP?pjpA!+Dscl>fE|k?9A=%(f}+@}tGv83?ft&3uanF3d&X zh7&`Pee7aKT{N?Wl2<+wQ;c928JPn09vTa?#Fr}&pQJ$Kto&|uG^pid6(l`jfaVtq z;Wa)~pOVN30jnr`MNIEF0I1gl@UF*FM@PRrv^xfK+-U-1xfvrIQE8PWP&E%j@ybwM zahXKi>nmcMG!_R_h^J6#5Kb1=M;Ob#k#(THg1$^hPhQklbRxH#0zCVS#k2-A-(w)F z8Yr~v`K<K4G zLy9k7So$ULO$#VG-VzEDsI)f3gR+#y3jUM6*)2F0(xrgCe*rAiMU87y^`jN2Qp4M~ zib14eS;k9rn2R6|jTNQsM7WOcZcyDa5=9e5)Z7Hj72gDS-)XEUMkY2<#FO>3?PXJi zvMAp8%2b_9ZOYXPNCIQnGD&KIPN!N6_QQ*?)^ysMnoeB~zP04ZW~4i2`b8??w$!*% zq>aNu)Tkx;&Wux_D&Ps$hWl}fiio3JnkhQb*WV3lrf5v-uN=tbX6%8~oIcQ!Zq4yv zTq}${*<2Bf5g+h?)$Rwhp6v1{~i;8QuzT|6b z7)V?jg_i7z2UZg($O!sX2g;gaJifK?eBuKVP$lX_+49}JHMF2}0_7&Y4TR4;aPGBf zp{NQ(d)ETr&b2`oe1-`xTWG29B))BtCcs;6R!M;hT)|=sj=Q~D#8r9(42@eB3@(+7 z*(KrYodm2$MFm4;`T55=a2VgjOJ*S^<447(*--u!)pN z{R%u~DIU-X*_neR@%mnHj}E6wi_a@yTSp1=X@~LSl7vD?q8X9KlSJ6if50@WBM-BZ zNI+7)j^T%x(J$D7a)qAID$4-Ce${cdfrHS zP@pV($e4mRGw{9|GOP{yVj;H$skn7oM*;DeZ{Hx+Jl{r9h2Gz$-APIZK)IGAPzx@^ zLvuu?HphZ$b7-c7g1^Vj&RY#+hNJ%w1{T>;UZl15dLL6=&VYI_Bev z-5oTD*=+^wX544!I9WmG>*+9;BQm7>y!BeCmBCpPhCdjdN@2oJ;R<61t z(4z0B_wEFS(Az@A;hsfNCjMX!C5eP}H47X1gJp@91P1o`Uu|C|S?Sv7+Etsbdn9~>XLOg4niuV>w+D{% zwe{Ax3-O3#91Yb1j+Z=GPj10<>js#LO&kr_v!1tRpSo+q;SKQi+2s@*KIl22r|hF_ zYYSe5Hlfl11dTjF@VI*OwI;wc&q)Rmfon460Ig+hUW2xvUId8XS5ll>Q05)b8-sue z7OG2(gRewf9~}PbDdKGM<5fjnH{|SC4X7p&@`Y1cP((0j-FR+w{dbef?&6?7(}FtsHNY-S{Z-0eK|LwRp{|h_{jm~2w5m~BloN)f-Nh)CLu}3Z z_P|oX1A;FV+_8ILDHLKJr6um}*^@&!!i|c6e;r>7d;#4y;j`QtZyNz~7>;|goaT%L04`+Rse?Jnb9%uz!T*ZAtgcR)SiaB^_o z0iD~9vfKT2HENU^;|}7(uMy|JEx1Oi9wSQEQ|m9_;IwE60sErW(IssxV_YDzdmZT| z@u$)hDuAg>@6IpJeK%-P@cb)(;EiA2Ja{mLfA4$}5Yv#E?>NLOz9>1OoZ_wUtrGJN z;^^%YrE=EJ-?Bt2f4m9LKPl@BQ54elXD%tIohhSs{s4DNIlkc9_!lk@SVgcZU){p6 zy6|fSjR0GO2dr>1U|h!wR)A|CK@}IJDJi3!{kt$&=$i zGWP+u`r=a^(do>56j*d?KWQKf7$gZToiYwSKX`c_$4j{Xo|LiO1)^!s}avbXk`_NM{79T zroA%|5Uuex(Ha?v);N)9jdmcZveJN2)5aS$*~zGBKunsnY|^lnmgp+Lq_w9d5(zMC zOsHAqzgh#Jj?}DieP&HxhIn43LyNYYS`cS|MMHuX&FEs)Gl(4m*RFuCmQ*Dq`-9sHe>%7*j5L-7$YHHIivQBq(va9n7 zntlco)+VlvL8q0PM=Mkt+SGIwTIUZmRhmw4bTXqO5Y}@rUiS?C(=Bhl062}Pjc5ll zLYq1Jp62Ff!OzNATkEe!;p*_g@Ymv7+HC?lpRV63+})f*B(t}+^17}MB3auZQrTj< zs#f1%T|ChD1vYcM#Oli~4Uu|+P*fg@mz+&3Zm3i8Ug3w^GmA?U%y(>dMZk7hgs8GZjo%wFv$Wg;KnfMfXdmV>G{;l zuJc#=%XVOQS-MRsnN|H6JQed9F16JzoBn#5j>8?Vn5j#nGXNU>$E#-+wsyGG9}_Du z0_wmhL2kxU{DecZhX-g?QJ_Kx{^@pVm^mH%6+KrTgZR+Wd z(k^_I#<)jo7hiw#Mtid+AX;M}qqP|OXf-_Cd1-lr%F^mfnnC($<**s~$z}^GxaTjU zC!$8yXLSjU8cNpFo@)Kzt(b5YHwxR_Zd+^CHcDkuk~-<}vtQZQTf^Y}+vsf8u^4e$;S)QM)rn zEeD5D6Mh}Jq17Yr$PKL?2ct%3jGEyGd6xOgI`0PWR@sdV6UWxa3-`zzt8Ry;o-k^- z90`v#xYoI*n@1916|T`1Et@ae31_p$;u5H1Lw;D6K2{21s}tP4S?+OCaAEbRnKZ;@ z(h!$PL*%S&Yj?j^0VZwx>=`^Y-c`%w8DJuLHP!9c@@wLEts6bHrN(d}#U(p54#U%a zj<&G(C<1L17%v5RYPu*S6J)XDr7&%~kZ_NULNQ2P3X?rIow}Q1jymSc^Q*lZ5B4zs z1PKWfCrAk}sjWrYEa0wF_+L?Vt<4%zcBHFPkvq~>F`tQ2$sFnun>E&sd5?B4=Btqv z4OQ!@k=Ty0=yT0PDVMiaLAyH0HpEU%l*)!_h*?Y56JRC@bJPX2C(iLsm3&GdXN$T} zb_%ZXGEOOJSmjAlSW$Ip^b{{<4WH}DSdevv?VBW-H3Vk1r>D?5MR3ojNm3zqda|63bh+CErp(&L(5L#bn=xARZjl@DptgX8}a`M776%2^8E`zs?8Z8Kdi`G_d*4% z8vAY4Fs4;I%vK!YHlN)C@M1|cJ3S5BgJXzya1V!`!fQH8A(2~=hR zFTKpmOHg+o=cPEf!n%i}zsxgG+6+%jI6+3U8ocCF27Z~d2S`4J>>Q!CI&dCR4+vb9 z@V@N~80^&Bf-*AN7*SSd1YQ!Jh%=>{AX>9#N@YCNW5zu_*om1^L`CQO!+%rm4}MlD z02~a|g~A{Dm%7G20?riqXGy`4aAne^ornzF5HzMVLW|RarQXQ8&yw;(BWJ_^0`+!v zHc+##qg5w+INOV=1@)%1T>vAj&k|a%@4U@OmUFgLDNw7ZnJ~F6Q>&<1A34Ory3Ce} z>+8lXa*Jk54Q$$QbWSounYzA*gLiMw&qtn?fN7Drj&M_j;!t7CQs8#!1Vv<|j~hhrWgAV;onfRRxM35wL&=+!wmf`irlcLqmt zu)4+0;3y6jhXT=ugV7}?)y~y1M2m*`9bg`D34*Qek~0{sST%vj8H`4(8m4gun>bil ztTtG4GvFGjbFOaTVA>}ZON&Qz-B><#bz{R~yR^slVgI9v6?vW6D`T)jpzxwALv_%rhc>4+QadI^92vq>spV9A$JwaOOh zH5+(E%9d7st8~}Eu3nKs(yFCO*9>g)HT+p44K57q!F5!fyIo3VPjBL{vOA>SEdL$+ zbz%q9bKUOZucV#QFYNSvDTIC8DSc%*9|GpTTYAhAAEC#fJyJOX>-ZRdj^8U)Gq4Fy z`8f7T%iLIr=cu~>pp?Y+ynu7lw_Q>p)*y$RgC!o44zm{TIqZ;JFsvfYqw7+6paG@0ub zM$d}oM3d%+Qm(W{ccgp~Y%t9QoHC^TCG{3*4A{-XZeqJT}ao3#! z-Q|KSlV3{iHdS`;4C};^qbjVT0CpE81$ppN1WGE$z)QTQ9xKxc+Cr3+3&nrq$W&z@ zc!}dv)q#wcI7(F|SYCqeD#~oKaU9Ky9J8ui9WTZ3l5(ke=_g*Y52h+gswl&MtHw(T zIztIOCrbKYpjJak!D;+AJ{T3P@Dd*kIAfdIJ@6!o3MS@1@(xvYnU|Cf^}$5e;J@jE zfzbw@%?g!AO`uhj^uYj|qNEQ7NE9V~Fd&vFf%O2U@e)@Rs_t#PgdS8)wT*WljV?6x5ieo(n);fT zFndj<#7otANkRO)gtgGrKPW*{f|5QM&}^tK^_2nPMoC{8P;Zo!m9g;;F$?X*VP4|1 zP<7C}#Al&0g}lUPp{n_LiO)jiYj}xILglu3i4R*@8IvTQTAmu+~i!DwFiLNACer#CcDX--6D;%7Edaf z*3n&_VJNJ>3+x#dpVB0`%P(LAFd9|MTd5La>Cq0TfQ7q(fG!l`)F6;`D{i@RA3!vr&LNj*)YwHOeMmGO$FE%b7byh^k{aHd&Ib>yxNZG)qGy^O-O8%J*2R&dPqvX$c4G4ev z8s)#){MKlzlu7>Ez}~dMpOq}K#lY$&${}fsta2p-o8Askxx75p4R$wt1#$)VzKYnb zzuTi&uabO+73qXJ@s;HqZrp>beT`L(-`dHA(%Qw!g$=CaB7C>1uH4Cu`$}9x z&-pHbmeh)qe=@K!i%|xt$jJ^gkk7KtOXZNX?G5El23C4GeyQ15zRz8(OUKKtAl@lM z*c30XF|dZ~(CWyhvX_CGH=yRZmRSA6&E(w%)O))N)OJ-1`G-|Za%0^ z@=%s}FMxmJF9UnG4?t{U4z{R^+@8HTgkMT0$t|!nN3ayQt@+bH-kO5+LwUdno7IvA z!q(W`rds}i1~{TowU!(w@PdvyIkr%_WBkG~o@#$bfnyGpK}LaNI92FDfm20IH_b~N z!>MXOUg8)|<&-^bDDs|Fk%<2YtgStY%}abBs+7b_9N(#$P+sErPBoJ8632HcFg!FYy_uY7}1LQ&5E|&oEo32tEl_x59q}k<^~M<|U59RXGABL|LJvuL>kUlyn@< z$*K0-Ew9Okt%_p2#D}fQW4y$NtqNr**|5qeDv~w-k&jyyuX%}&Tb06iiH}X)O>c)w3w4Ec0HrjYmC;SRkwzEVERkpK43RSkV zL<&__Rr?r>LX_@R=ZK7ahAKzIsX2={F8ijn>LcF|cE`)9oYQ@pMP-BVW84{#*RC6ZA{1J! zJ*~>l{vj7hnZ8t>Z(w^agL_a=bNq5S%)p9Y!B6W}$eRrqo&z_P-Xwb%(rl~cx^C6bqQ?31 zXKEshs__mJH{k%FsECqE5$lOpVR>a2M#dP9cx^6IcDsSj2CkF$7+BbC{MmK`=(amv zBG#GxH1u1^JrEzb_Nd%)*ES+H@Ly6lFNo^$?5WE z1MEuP%ka~*OV}$O(7FGz+#bLYTpX->MIP;j!gS0z?dvtUH?Iz=9Gv#+4SBvBm@Dvk zL21oz%ddGgg(9Zh1Lfoe-h0dgxxPCJpvWOF3u|(x`WEWmmz<5FpUu3eA)1qlAQMajl9Io z1_P$H!9aL;fm$nY!lc-96-k35aig8P=1AOV=dL-PHrlysj*E?U?wVs?qn*3vC>2|( zcgNd|ge0ZPQXHom)!97)z5Dd)kl5XGz;An+c@6NnGUvZ@r=Q+iSz_Px&_k2`PvtD}CGd1iF)ZBV~3kc3>~rUbgiJGXa2l1?0di0wfdj6eL1(|$!~+t?ug2rrAnos z{l&NJOxy7Gtl!6%(o?tL$M>&z8oY3cPo|35?j9Yn{+GWxU4PX)+tU|@R|Q_wG}g})Ki=dVes4j6C7T=04)EHaFVo}fX+x5R9*KQD%n<&&N1qOds$Pisey>P#!^BL@ zqbpR%W6aSi!Lvcs@QL^8{c_{E&000<{sK)Fwyfc?WJ<{bzk6)2lqr3|k{dO~^gh@> zQ!6RpR{mSjC0Oe5;o;fNpSUpNYV&u6zGeBNSCdLR2X?*~|KW3|;kzdde-)Q$fd7F5 zQk~`dtKJ$s{_#@xBI61dJiY4BluSPw-(FICVCUik3r7uKG4w+~l^>U42WLuryyQV# z+Otyfa#O2eSPie-6ve$DcvXALKLlsQ^1TVk0xZg*=`^esOBapQdhetey@YCz)H@}9RI z&9AWJeWqyh&?ifqpUdmt_qPMnkMt~8KUbyQFUIEG(|!8gqjS&B{M**J|GDnthfm%2 zb#RsDE8eeevF~QR;or;~x}G0bX^2nCKHG)eKSsSMT5f5Zn|*B`uCH#I>w&G|ogYVX zbzIeY?&2aVyL9vJnCnO9iZ{Q1`uycb{)5?)eLIGKF${b2deaC0OzvMV)%U&lzbAFi%iIP%Q+cG(I#y*V+aUdxJ^|GLw> z;;xSyyQcn9-1PI(pdHz(`i~wRQ!mOhtGoY!;7Vi8%)cCdG+=Rl_f;4AHJs*gvFgE8 z{{vY}cYU+P{8YeJV^hAR*T3yOme9WI%zer0y>kzWY}lvs+Sb$0PiPr2JmFUFx#P%V&Ifb5;R__aCI@}EulcO;i@>v=Tv*vcIxw+9Rx?=`+h`5pCY-LocmoXrkIY`!qF1+m>;GH(Ex7;es5aL}ox9h&`Gh(ChXWQKjH^{A`JnvUes{~5xQ2zZ zXK5T?FS1Qwjs;2@wq2UATY$)tecy~l>%|U-8uSh=H zs7fqLsNfq{ba;X8v5IlKT94MQQmgq^pp}_RW8;a{JGH0`fq|8ZaLsp?%<4Y zTcI&mRdugZ!T{RZ|k|yr|G2%zb3r6eEXlbTjs^JvRzxSyvn2t*#=hX6ybNZ zfLG_l&=c?9uioCd@WA|j*7+5V9LyflYQU#yuXFuac_;8rt6a~&T%BS(``_=I4?K*j zd~fe>6{ZiF?XhZFu|8Gby?yA@?eU5Q9j}^)^+`Y1@7vpH0Uw5z>~`tP^l84;PoKKf z*!1XK!A_Cyzjhl{$=Bq+<--nXqHRoKldYMiU3#%P{otj@$YZlYewuY_W?Zkv50)J1 zH)+pj!_Jk@*H0MSw#`r1E`D^g4LDj>2yXP;x7M-W_z?I#$Tsx$w!$gNqFQxai+qe%&VBZt_p+p18sf#~dk; z{3_eS^og$*)=F;qAieUsbCzYSy%1P-C;v& zgIoh5rk(2@KmU~by`Os5{`jp*bK9csk4Ll{u&2$m>%9v<`FF~SSBJN*I?*o8zrv{# z>CJx*xxek|q<_X9?6YyX+0tcMqp52LwtIN|gv~bSvsZG_*hN?Je5hec_HXrRLZMLy zpFO<%%sA@AqQE<~gKW{cQd2@6Jna4>fBh1_4|_a1VZnim`4X3I@;nk;vq4Yx`0+b= zOb4sgHl{-5{%vAL7?$t2mDqT7^ON(w{ME=mTi~t4QTbL>X}Xx^J)d$CGSn zehsrf8u~t`&xzMTw&dMEUfjNHE&u6F<4?EuzTEme<@vEjud~>!J1aHcTx;{Qty>4K zz0@e7>Fgp|{N}Xxt~p}U?>^F5Y2(VX_jmkNDPd~r`C7^E@(e2TvE8ofr=H!vKV;^U zD~){m4tdnFXpI}Q9(;Up{nhq=x3-+~cH^!6cY01fIWwj3u0E!V#coVJed66MTh2`f zYwrn2m=N%x{i`BNE9Hq<7Vsfvbgi|vdyAW7`Rl`*RlO?IFWqxQ(~(Pkw>5|wc`@6P z4q5&(cE0ec-nJftemd-F4jnzucVznB)GRYI7rHn;AZV3$wJG_w8A9Wy1=Nktx#VlM zgmJzfa!g3_UYzh@U#?3@1#70JkN$b&&GgXcXZmLGxqo9A3I{*A$z>Ad~a)?2HCS@PHnLyzqHE3dyOHd&!ynN!^5gSNV)y#@m}+nC$`!r z!~6?DHkSIuqFKQvbVu)TPB}v znI`*I89u=`xLBbfW7<4!e1ETB&b`Nn{%F6obGeY;AMX9P+q_j3T6X?W@_4213p+-{ z%$(VGNsH)0E06cAGri5c!Rr#%m9KHGV5m>Mnn#vCsQJ2lse;y4K^uk*`qt%apUHi4 zh1ovM$dS4B%7VBd?FL1Q-r7MWjk=At3#qwXK}EHE#odA*L4XXPvS z-1y&i)3llSc18a)`{;tmgv=+_&3>~Y^X{BIR@`cTy>;4+U4w^w+I#CszZW*2_&-iB zT$lUxk0EomcimE_LfWjlv+kEzS-)ah#t7)lu{U$s(wp#ksFzd&LSqB8iS7@E^ zDz3qdMz8x%So&X$o`>%Q-+mr9p+o!ZzYba#GisbI=kqVKw2lNYUEP=8 ze>&q-<$r>L|804*-hZAw`;PRS(`e^~wxu>aOUd)^_YUn6e~D>Ob4Y{E4@YH{}$hyQMT&n7)7 z*LY#8KW3HtZe5c0OW(}4EBC^@H-7M&81!TNkKZak@;jNi`vGfw!7^RS&mvv(aE{%t|*tDls^7hrS!EcW}mogoU-8TywBd}lg?Mm`YbqR*NU%$ z7M|TOy6C0!BU{|M`oH{nYMZ`Icm6wXSmvsmZ1p-%e7g1C;C`>Fy|`KS^3?+EX6(3U zD{I0Z6YJFdXYAa8ui~>N9NN73>Q&!PgU-)Qw?3Xc#k#P*c_tOD(WUrS@1&z0E1$h)tFnH0ub1=x>k)kQ%8m3w&G#fd z`q27H-+rxLd`eAA-Oyn7sh0CMw)nHpiTl;-W&hAOHMv>eCd-%p^m~fm`s%)0Ln?=r zEPtx=`4`gf#kZHJ;a%iGp_xaD%o*Bi+o6{;hg`nbFYQ#xe~Z_hSm$(+#GjVmys$W? z*X-Kf6PnbRm*;z?f{AtF+u2@JUbcFfaZc&^?SGwrVcpK@fu{7bv00zL&T%65jcaAc z1%CXq#>R`C7dQIl-StPCZoTSPJ0U)4+stWS(sCRdI-_6Oq!qok+<5rs;%;ePjjvg| z_i8!yhTJrCTK$F}di|AU!}YXo6GuhF^*uFUTv)l|ZnuiI-E}58=dRWZ%d}0tQmu1( z-ALQe0#TiVmQP7~y1m)_UJJ*^1)Xm0*Yk0XlcO#as5*Jt*jpPcuO}U=e5OqOrp42? z&cAVc)6Uj=i$0!tW9aGC2```TxWDqnPm+>w`#|Mqd-+8LcaE|fq0`lrBr zSB|bK*}mDhGhzQ0f4jZyuixI*sxZG+y>+t!w-#J<^30TJUyJ3oRSh^CJik_<9aoNi zo0ZscYPR$(JvzSl@AtAzukHytY#G-!|J2Ca2L_C5_Gj4UYoX2hxc!*rfBO8}SmWDJajn-n;(pwxs;*$ARm%)~mX@_t<=X4FgMd3_KFkBr>A(jx806-MF=3!|evY zWu1C9=33f}kWV$P9WEDCJ*BBv@dYjZvkf-wDj2q@R_u#|^EVtGQ1i*%8WWzCn%AcF zhXZomRq^cbnf$YUwE6n+&(O1@>%@-O7XRz7msj^2vL$Thmu`jr+%lo>%o|6_{r0TJ zQ?H2St=~li&R;z@WzF8RCI4OGU1P?SmkALq7FIYp@!{ptmzo@U*ZuG8U1B3oHE&p; zYWsk#6EA()*4q~N<^GJ1eX^_x-BG@e|L+%{tsXP;<@C&6-pS48#9set^2UFTR2}tV zp8w|Tks({!cwYOvZq}%YV;`Mw(7b#3Yp0Xy-`MszOV>Sr`8|I=XV=butHwr-SSGKr z9=P}K^nBL#u?rH*WsWL0xzYHoZxe$or|UkM{;h70aSb zxnOy&YvF6pB-P)V|AhJC?-v?>Sv&dp#ePXI=BBP_)}qFYKXWXo*exz++N57bRy}Fy zSZ-XydP&FDjqhKpZV&%_PddLiA7ErnQ=cuLUZKReM~M?cMoiynHdajdHR{CqUcawy za;M47%rhVLi@3V$>xS^8$a#0V{QGmSYpMBdV_w=mPv73VX_+HadNoUFWh~n%+sK|% z>wBb*nG@){;A5EvIk){i?c~fB?^fpQGo((#i-#)gu4^pTKgZEWw;OC-aqE)L&h&l@ zp0CZ+`r@T4&->Nu*?Hm2E;T>R{;B++f2)o=Gkn|9u;?@1SA4rZ|jKSsO&p zZrm_$e7@Qp;$tf=?s9gO?b(eSrT32x${StfLFU|2_NcS%Mvsu#(bHXO&Y53aF6fc_ zr-UV^lf3+E`KMnUJ+{j)o=GQXcU#yle#`7uWv6YeH^Z~ui#!j!-L_;I*DGXNx5hrL zT2AvQ*|}Y**v-q0LDQ?(DR;2YflsY7V?4cP)HHR^G49a%=RI}}xtzEocIf)g%bLfe zHhh&O=dt36A2ux>-808g>-ZVF3r?QJ;=EU$>u~K|gVLvFv}|&7?fu))8=CbTb@Sw^ z(PhIH{oJbM@EO+)U4QC#?ewxOuW#IcoOY?sn1#vBZhnjXWOF|hUp9tCq{}>^MwNwf zX;v+Z$Dur`$;esN9gSC5?S^hG>WoeH@(5-#;`j+bpo{uX( zDMz7fbz&!-+MO`s&Hjd64sHyX)1&;D)^+z3-Inwsxn;rn>kD^mlqb_aUNuuKyAC`H zdXo9~tlu}~wypoG_;0V8^bgwBa>|zjSySC>oXlM!$LOXhdj`HPDdlg^nl9;gvO61m z>3j7dDIWLo&pnoOxJ=K8JymYJ@UDHp|Chi#_0ppQV?uxIDcSIY|KY7^mFC~66YL-R z?ytsQ^FIyrn*C_RyJ*YH`G@Y+I^H77g9-(&l#2E{m=z^WEXd zr}z={%;r(nfbb^8ed&01kEXo9RmBYI{ak5Hb9yW_@YjJgvnPX!zXY>*d)Uf5OnK1v zL))k;X(Qp8fq*bYN$ae99MG#nM^CO6g`@F1Z;!Gv0v!+^7ns|lcqqcmxygzD3rG&| zV?;0yDuQ#mf5PlYDqum)mz-em28vAL;sYdzfu_cbnVLTz-a2JvaF|!@?tx zkP(_-XBhmFl~g9qFy!op9-7os6t~Xx;6G#H#w7SfI;IkCG8wtm%o&DG6jy#{SUCJ5 zxkbnsh8$?&+{ESrL;5M8q=oOF@ma$zva z;|i`Hn_zi!e9V8tx8dBD>sk*{A7oV#6b1XYYduqA#keg1756m(rdSXJm~w(e7}8@| z3wo50On5$pc^CBXv5}FO!|9%z$zCGEXgIgUx^`ezvc3o~#mP&6DKYOHW^?Q>9$6;` z3lEBmrxFp$B2K_yfGNmelu#C-VdqWVXWLHg6%15}gsOMAidufs&npGc&ol z79+PfJ2j1#5wjzpD!_m<*xN!_dU9Cs)=dU5icEk$$u&R zHIn;OxQ-o>I%G+4Y7j6`IHO~OP#xNYkvk*^&6>FhO@NtTF%x0RJHsyZ0O9-x|K~V1 zz$oOr;z?xgUcvv_=ZJb_(ePxl6Sh^6Esg+pLlnNXpI5CtTX+O2X3(IC`?v@n8@Y3b z05fy*pa8RQnj^w8m>j~GV7+v$sHV;pU_k1mo)Tm))T1Z`iDbE}gHTU#gi&BdjlLr* zr;-prsA%Ty3a&6j@P{++q8S`}phLRi$U{kX0Xzv=ASAe>Fra7BJrabdFsGvvsbobE z#%bh%F0L>HM~El@p@_6zq>1|mxqgd`R<7;wqZ1WQk4dD3`{@cFTj|k3P&pY4G9I{g z!uyCM6a}Ff5vB%WCs9g>ifhM6m_TL%|2ML%aODQqS@1C!?M@a;C#}v3O!2c7U`j;405eha4L;S;vBs|0tV$r7@Ueya3kxtM z6x#&`{*b#x39xWNbFeUk4aXuV+yz?~;*s4JuB4$88lr3k9#-Zq$U;5E6<2_n2tSVq zb0QxArmznD5ZDocHC%~tcWqGhuoYn8++A0I!MU2iK&}Z)$x)<#s|t!(U^+tNfEN!C zV&MrY$IHnSeIO26JX0Kdi0H!_Q5kQxizCF=l8=#Tht`9OIvWw<;lpy3_Q*qo5{L$3 zhhQuy9kW79K?a8GuXGG%!Z?A~({Gsr*P%gCn-qbkjtS$0+yHdtkf)Ih2Kpco8RN-h z0X2Y1L&zbN$qLR%#1~dDNwgCqQKJA02ndz;VWN{mxS6rNxQ&R=60xflIy17Ykh00a zMGO(yZfspN3k~%s;SV={`h^j%I^+xW2xM-d9=;VwFHkCo7|4p)W3n{xAZ1lTJ@Pap zEx@^x^a_7SGEVqplHEc$GoCdF1<|2RKp`nEozcvFPW3y=|Bnl$e>`kdSoWZV?&!#(zFWSDlrHGOv%$Gz%(fsNXLQmpoArxU{c=D z6+Si-f^RivfZxE)khKFQbKVk;^pK66>YmUbJy~X|%R;<0A-K@I67Gy^W69>4EkQ&t zgFGLE#epW7b168Zgy%;}I>OYT9^q1~kekRw&w#^06grWbtYD^aN)!U&*exyyh)2gl zxfBGdQ~a3$hr{(jWPt#3^pT=+3(y4<#R$UN#ZI_DPPgBxM0vU%C%nE)R>o?IMq1X0 z4ESa%#94A>FnHR8k_|}cN_jon8HUUUh^=*9N5H~$U6!4e0O)#jQ3)_5f>&seTm{rq zf^&p=CXum6JtgUvQ#~8+git%cEIh!*sUoijofUyuMg9aYPAJ*4T)$OcG7w=_%g=JZ#Fj;i6b&%DlE&%UfwLFLAu19P08D8HCkRR!IzU3v(4Ht3@N0+YFS2HcaUq+5 zKq_(-VNxPj5%C*jA_yWOtA&dbDd=V~JCn$+0cKZaJGKP;3TY6^7qSXm`68Yc*q-zQ zVbgT8k>OCgkjn+cMLWp=J5tRF+M{<1Is8R3Y(qt;#K;Iuq80(a6!@dI`-LoN5@f$N*uOAZG#UO>!1s(WV_cnTBnu=^LYtcG44QSORFC zehftunF*ojXpiVDBDt|yY|jQ-BATL5QORNDx-wASli68d=H;ECyo;W1X&=YFCvR;HH*3x-X4#+b6JasaJy-#jvZxyl!&qyXeY=W`B-^F zP-qYdyx3+wA93v9{>U=n?Mrf4A}~;Kf4C60C(QJ?4mstT=ob$YMa5LAD?? zFNSZ5uvcIV=(<1wLrx;JM&x>e{EPJ zx+b0?@QH+XiDWT#q2M20)kC5a$Gh{ie=EUhplL)D;gY&|aG(JdwP2`bck*L?)nG3o z9da)$aYvATmcqbeiuLdU1cfP2v$-51j6xUK92^HoD4`zkDIxqWjw+oMQofRHN19MF z82Hk-?p%K8qaZzshzfK+91qt*gcna3JP--Gh=jaC>LC>o?cPk#Pb4lf=^bg*wCOml z5Awy4PGIIDrw&QqNIeiu*Lia_oRVz8bz{KUy4C|nh9tbAqZnXH-geiI;V?puAaX{~ z0TRDe>@y@#@if7lVPdH!kDN9f19}VLdO$uwjtH`tuvL(=0aZC!BfJnmhp%Llcg5Rq zCn176&L82c@sJ~tJ5Z0XP0%h8K@YDsI!#2w+u$+j^@0|X%ntGnnVrc*s3#7njszVz z5Y`K_VaPR^!KgtU#2qscHyvbshU>Xl4+n+9fRjl*CF^fEXqbb^i8MzN4G>(r2-$=z ziTA`3YlFg&dk8U~ED)0LlZj^_=L5xwMo!pwsV*TBBE8n0(;bFBfJ_|r3o>zwRrH`i zCrUyz*DGgHUXBo90wv&g7#l-Y0g2{aFFUUXmvnI#aAe6&TPcl3u57x4Fk16ep{^rD zdt~`x!xe8|6xYR*Z{hYuVBlQ|47{)gvrARbQd9g337>2U>`dZdz|IgFh(~D%S^|X; z1p*sHWU3qj*GninEUiQ{3Ofj)ZGaKh2Y7&>8)OlOkR0o}{P5x;VhtA~#j}9d3khAs ztDo_>P>3%Pt*6PXpsdLb7fS!*Oj z6mbR`r6&%eH?0R_t9a5O%VS8coC1v1^g1K`78xKO8=?&=sq0-3C)5%2z(K#_n4Eqx z@v0G7AQRO#fJN4clw&KglVrh-)QkX~E*(rB*b&Hbv4~oHXJGFjKfxYD76aTB>EA>` zI>0w8>Cjvk$YdfW3&g$geubR@r{Y*O)gk~FLBcj6l{Vq^pp+sSMR;EmCKL6XaErb( z4rfxwibD}VRtCCTIzThUBRnQbJd2Rv$O^I<7Ra69jUacDiwUIzX#+HZ)&n;u_67e& zGIn^?)AsDP`vk|tVK}0l;8iKo3DpBe!NHV#%kFjHCk-y3B98z;iJn#~mA7GJCHgn0 zHR)PFEGKh>LIOmzjq8zw5J2VwWj(o`&~S(g33N#CVKiGDi#ftoouF(~CwLC@pGZ1L zAWm)~RHveMTO>>mM8%GJ9DTXoCL|Uo90jCMvOfsDB)l`!PUNt_gHCkS1gQ;oQqE|% z3AxA#FM(|3gdISVawjCIUU$gYgrNhB=<|@ooNf#>iR601G)Hz7%@K0M13}47M^Hf? z>QiD;LVk1Qs`B->Un4|s5W))foDgX^ArdYN{3e|U1Woa3f#f@rC}sa)%upViayjo% z&NyK`ZK*L9@w~%hlUynwej-IfjY209Wit_04s@R$I4JML%Lm?pD6U`-APRB7h@@fS zcY-4)%-^y6u)mT{aK}Vc$^A0ODj=`5h^ipU68k(zn9I%K>yMqIUPRbU!d?JI2o|zK zQyc(a4YKd>tsoOY&QQAipciB&aKaGz8Yqbfat41!NIskt>D9K|Bj6mZ%LG^hdYv+` zJ;0}vXitzqn$8$zcM-EAf3)kCVEv&2Q(o3}J^cu47fCOa=tNx{jp$}_7R=PlhQLOm z2!P9vndpuo5zrG1azqdfjtALe7+c8J@o++c3`c_r)K*;#iW7nFI+-y1L&?Ixja57fZ~@bI#IXnf z5)}#7ifA+-4-h*sWJ4nL0Y*4Iq=6Q2Ss3_L?%E>E4w48#gixA5KD*EooP)Rt;G#2V zLU~cflqzz)(Yw z7!OAzYrz#3V#liF3j#s#7BV`x;w?UQ&=)fH3{>~P-2`nJk@K7^J8m7?Q#b-UQbxWK zBB8@6mo|uYZt-x&Tgv_`W)LzH*ssYRL&YYZV}#l17sxRYggesq6r+smsbYi!iItFM}9`kkO2%&BwSPTvT6pJBXP(0N*mqb$!O$$Lm zFc7)WCcgeKBv304tV=}40tZmqAe8Om>4(*jYzZzCL1{2dA+eNjXn2s0xOZUN2~NXp zCpZlcS`$4Im_LHx5apxYx|)vDk1mLu!xc^9A%sgb(c@WIOcW=QV6DkwL{ij(W(gmM zj)+|aL6qcpA`+ZvKLF##o7^tv4$p8$nOR~x8rzRanejyUgmxY!SWHtsZm^XiY634z z#|W8`oIEhdWDmjQ()N&YN8IaZ#S_|<2$;Ydl1>nBLk9)DiakX97ub zuxJ_)KoS!oRRL!cgwHvB5he1NbTSy+7jhc#QnaIERn9em2oReNBn+n!Y89a*Ck?`U zLmGs_kJdv}m$>}!q2l#grw22o^Qvrg+}FhF(>D#V5uIvtaljtSX|2+sxm zI-#&8Hlh(fxo{{XQw7x_BSU%}TF*jJoRuoW;Ic^D0}4ia!pVg#g>;MrXryD@Hd-%( z0m73(tOuom6IY_0Ty88EJK<_+@-c)4TF)+?+0Ovn@H1$Snv@_=(j$(DZl@8dCl`Sc zv_WX$$N-@=BLhTME?Q3=AYXsSsDUF$MW|>948A+06CgHPkA}(MvN^Y>>_2xc$e=;$ z?tvUvB<=?G1_;kHQqM?fC88yWkcyNzs(zA( zjO!W|q`o7>&kRKs=>%RyW;UY>ZZG|b+E;*PXcGwLCOe2zLfV6XMC;jyChoU944P2mw-3~3)~(>7-$wnQQ+Lgdbk=K<+)M_ zGj#a0BHU+$oj_o71`Sf#0w%Z&+H)SDMj=3#X@ih&X~!815TTo-9wI%+L|}3kIXnwD zd5D~w1^kI9IYB8(SY3#UWSe;IMbZgqHtB==&SO*!^%yTrUvR#`NgG37s|we-qN6 z^6Z`qLbt$CgB&O5?H$L-OU3dQsIl?nTQ4jKStmSWNMKx@D)yg&Uk9ueM9PBthn_T~ z*w79}q@5aZV>>x5P{26`uZ^7<8hH4`!0V6R*$k{us7D+DEU;lkvk$$Ib_BvWnJr{C z6N~8M5eN%2xlE8y$S5IzQ5X%w;@rI`eEF z2c!M+e0)b zFr5%p48nm4ri527QL*tvT;eT-iAC^t2m1{72ZAbjCN2^6BDXGaROOPsc*1cW>3V|; z5pOP(LXil2<)p-cZ{Pz&m!F3yl6o|d5!^Uk{tVJy@B~^qy|Ozf!&{nY%z)F#orbcF zFmiwq&n2F@OFYIfwTqrmHXZ?EAB`>sayFWNOcM_vOBV@a1dMJ89PGrqk8EC$T@}v2 zY59=`RiqW%PnYZ+`k=53ZUii2Wb3#CmA;*No&ZpPx`Z&7>HB0~8SYi3f2`#g;K|R( zY9Z*8!k`!vzO})hl!&*`A`#SUrOBXhjF7ZMXb|>odI)iG$e_7lROHOSq!MYATSG*= zX$8|lJEnvXYd}{J9E@WXG|>hZg5Y6iyS=}`BO`wj;{0y86XCRtXFZxj4p?8pcBgRej0OQ_oh{6y*Afx?h` z3|vjl0+0$Jy+EV%TVp%X;(^E;s`^Fzi-?v{4;iXlmzsY|+hYgDfJMVJMF|wu3CaMB zpc}xH_n7&}^t%EWK~;bebOZXNNGZxWcYKVP4l;HGN(sA z#_a2(;yJ|M5E&VP8a!bRpPbX|U^8?eNk#fVJ;D?5*d5VI3z%IwYM*cfY~(JSHabH^ za!deI-kWh548j{k5f$}F{xn1Zk>>{hgOrHL@%49%h9;5c&(?^79+(i4lpZj`E%Hz& z2SwN3yn&{j;5i;^B$5TdaPNiXk1!D(6K)v^L_j4hgZM4-2s`#&-MR?iIgx2bFch(U z^7LgQW(SNYvUng>2K9)+2VtI?3Ipr!Sbk(!6AxDevf_xV04*IEG}vR2p@QAoDvFt4 zG+kY+`ToNqf>S6g7vg_Ku?&G!z!qXXc#Vil4QwbXydbaOY>MATTiel!uq%*?Fd+y? zl1FBV@-1K)bj)H#A&?0#G0|pWxp7AN%36R#lCD_HFqm1vxswygBP_}EA+-yrAKun* zITfal1VclBfq{`ktrD`k5Xut;3M!h*;T-@+6tP*bHR24w=Zhp1;((H+$`u16AWYp&mRM#d;vW6z1&Wt6^X$SVcAj#x{y)AiRpY9&VH)dy6ATus4ro6E9P= z4YqUfP{S-IY7PB;(6rHSZD5qd zPLMyHEFo|i`4~bK86Yr#*dBa=$+yUEpxzS9-;ROd^+Nb0thC6wMsZnAoE_ABqQruF zB=iw5*QjN_{yZjv@D;#=qSGZrbE2#R4A@avK`;xVY6Ovri@p4t#*zLseV_6RcM*9rJo1i=y{856UD61Wsjy z^q>o}#|ZT#j4=dDQ3cO2x~^8Sdqx9D9t7cj(S&T{85FWI7@nvm!;qoC7FN}wN*!Dg zFJ2%#_T>luCo~U2F(D~X=Mhd51b~nkgn<$+ z6;5H!=R?_l9z#m@9c&u8&B#nhR{@?60#5|%99#=rR|~OeM2ia;cs>C=07%@bIZV`$ zpgHm|CSWe^pM82IcInokmuH0vVU4>C>Y%(w>KWE3C8bXQv~OS$0$Ab%kNnvY4~nJt M3=FIuSHtsv06l&Op#T5? delta 225070 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 VVfuwp+}Ch>1y!ur=)LHm{|5xqr27B> 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") )

EWWW(_rG6ZYF=hooaotOg$`xUJPPm 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 n3vxr@yjWLINDZdByG?89;&|WF8 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