diff --git a/.llm/BETA_16_STRING_SCANNING_AND_TOKEN_BOUNDARY_FOUNDATION.md b/.llm/BETA_16_STRING_SCANNING_AND_TOKEN_BOUNDARY_FOUNDATION.md new file mode 100644 index 0000000..ddfdb33 --- /dev/null +++ b/.llm/BETA_16_STRING_SCANNING_AND_TOKEN_BOUNDARY_FOUNDATION.md @@ -0,0 +1,85 @@ +# 1.0.0-beta.16 String Scanning And Token Boundary Foundation + +Status: combined Slovo/Glagol release scope for `1.0.0-beta.16`. + +`1.0.0-beta.16` adds the first explicit string scanning and token-boundary +source facades to `std.string`: byte access, substring extraction, and +prefix/suffix checks over the current runtime string representation. The +release also promotes the matching compiler-known runtime names through the C +runtime, LLVM lowering, source fallback evaluator, diagnostics inventory, +local facade fixtures, and release-gate coverage. + +## Scope + +- Add `byte_at_result ((value string) (index i32)) -> (result i32 i32)` to + `lib/std/string.slo`. +- Add `slice_result ((value string) (start i32) (count i32)) -> (result string i32)` + to `lib/std/string.slo`. +- Add `starts_with ((value string) (prefix string)) -> bool` to + `lib/std/string.slo`. +- Add `ends_with ((value string) (suffix string)) -> bool` to + `lib/std/string.slo`. +- Mirror those source facades in + `examples/projects/std-layout-local-string/src/string.slo`. +- Extend the local and explicit `std.string` examples with success and ordinary + failure checks for the four helpers. +- Promote matching Glagol runtime entries for `std.string.byte_at_result`, + `std.string.slice_result`, `std.string.starts_with`, and + `std.string.ends_with`. +- Add LLVM declarations and lowering for the four promoted runtime names. +- Add C runtime implementations for byte access, byte slicing, prefix checks, + and suffix checks. +- Extend the source fallback test runner behavior for those names. +- Add focused beta16 compiler coverage for lowering, hosted runtime execution, + and source fallback execution. +- Extend diagnostics snapshots for arity, type, context, shadowing, and richer + unsupported string-scanning names. +- Extend standard-library source-search and local-facade fixtures plus + promotion-gate inventory alignment. +- Update README, `lib/std/README.md`, post-beta roadmap, language roadmap, + release notes, v1 spec, generated stdlib API, compiler docs, release gate, + and standard-runtime catalog for beta16. + +## Contract + +- Helpers are byte-oriented over bytes before the trailing NUL in current + runtime strings. +- `byte_at_result` returns `ok byte` for a valid zero-based byte index and + `err 1` for invalid indexes. +- `slice_result` returns `ok text` for a valid byte range and `err 1` for + invalid ranges. +- `slice_result` allocation failure may follow the existing string allocation + trap policy. +- `starts_with` and `ends_with` perform byte prefix/suffix checks; empty + prefix and suffix match. + +## Explicit Non-Scope + +- no Unicode scalar, grapheme, display-width, locale, normalization, or + case-folding promise +- no JSON parser +- no object or array parser +- no tokenizer/scanner object API +- no language slice/view syntax or borrowed substring view +- no mutable strings or string containers +- no stable stdlib/API freeze +- no stable ABI/layout or ownership guarantee for returned string allocations +- no performance claim +- no maps, sets, generic collections, or recursive JSON value support +- no worker-owned commit, tag, push, or publication before controller gates + +## Expected Verification + +- `cargo fmt --check` +- `cargo test --test standard_string_scanning_beta16` +- `cargo test --test diagnostics_contract` +- `cargo test --test standard_string_source_fallback_helpers_alpha` +- `cargo test --test standard_core_facade_source_search_alpha` +- `cargo test --test string_runtime` +- `cargo test --test promotion_gate -- --ignored` +- `cargo test` +- `git diff --check` +- stale current-stage scan for `1.0.0-beta.15` +- public-text scan for local usernames, local filesystem paths, and private host + publication references +- final `./scripts/release-gate.sh` after commit and generated catalog sync diff --git a/.llm/reviews/BETA_16_RELEASE_REVIEW.md b/.llm/reviews/BETA_16_RELEASE_REVIEW.md new file mode 100644 index 0000000..cfb72b2 --- /dev/null +++ b/.llm/reviews/BETA_16_RELEASE_REVIEW.md @@ -0,0 +1,55 @@ +# 1.0.0-beta.16 Release Review + +Scope: `1.0.0-beta.16 String Scanning And Token Boundary Foundation` + +Final verdict: ready for controller commit and final publication gate. I found no remaining blocking findings in the current worktree. + +## Findings + +No blocking findings. + +Previously reported blockers are resolved: + +- The unignored `promotion_gate_artifacts_are_aligned` stack overflow is fixed. The beta16 string runtime handlers are now extracted in `compiler/src/test_runner.rs` and dispatched from the runtime-symbol branch without re-entering the old recursive path in a way that overflows the vec_i32 import fixture. +- `.llm/BETA_16_STRING_SCANNING_AND_TOKEN_BOUNDARY_FOUNDATION.md` is now a combined Slovo/Glagol release scope rather than Slovo-side-only. +- `lib/std/README.md` now documents `byte_at_result`, `slice_result`, `starts_with`, `ends_with`, and the beta16 non-scope boundaries. + +## Scope Confirmation + +Confirmed: the beta16 candidate adds byte-oriented `std.string.byte_at_result`, `std.string.slice_result`, `std.string.starts_with`, and `std.string.ends_with`, with matching source facades, runtime entries, LLVM lowering, C runtime behavior, test-runner behavior, diagnostics inventory, examples, docs, release-gate coverage, and version bump. + +Confirmed no beta16 claim for JSON parser, Unicode scalar/grapheme/display-width semantics, language-level slice/view syntax or borrowed substring views, generic collections, maps/sets, stable ABI/layout, stable stdlib/API freeze, tokenizers, object/array parsing, mutable strings, or performance claims. Matches for those terms are deferrals or explicit non-scope statements. + +`docs/language/STDLIB_API.md` reflects the generated beta16 surface as 582 exported helper signatures total, with `std.string` at 30 exports including the four beta16 helpers. + +## Verification + +Passed: + +- `cargo fmt --check` +- `cargo test --test standard_string_scanning_beta16` +- `cargo test --test diagnostics_contract` +- `cargo test --test standard_string_source_fallback_helpers_alpha` +- `cargo test --test standard_core_facade_source_search_alpha` +- `cargo test --test string_runtime` +- `cargo test --test promotion_gate -- --ignored` +- `cargo test --test promotion_gate promotion_gate_artifacts_are_aligned` +- `cargo test` +- `cargo test --test diagnostics_schema_beta13` +- `cargo test --test benchmark_suite_catalog_beta14` +- `cargo test --test reserved_generic_collection_beta15` +- `cargo test --test binary_smoke -- --ignored` +- `cargo test --test llvm_smoke -- --ignored` +- `bash -n scripts/install.sh` +- `bash -n scripts/render-stdlib-api-doc.sh` +- `scripts/render-stdlib-api-doc.sh` +- `git diff --check` +- stale current-stage beta15 scan +- local/private publication text scan across source/docs/tests/.llm +- required PDF artifact existence check +- `pdftotext` plus local/private publication text scan across required PDFs + +Not run: + +- Full `./scripts/release-gate.sh` before commit. The script intentionally requires the generated `docs/language/STDLIB_API.md` diff to already be committed, so running it on this dirty release candidate would produce a known false failure. Its cargo, shell syntax, generated-catalog, private-text, PDF, binary-smoke, and LLVM-smoke components were run manually above. Run the full script after committing beta16 and before tagging. + diff --git a/README.md b/README.md index 608bed9..b59dfdf 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.15`. +Current release: `1.0.0-beta.16`. ## Repository Layout @@ -24,7 +24,7 @@ scripts/ local release and document tooling ## Beta Scope -`1.0.0-beta.15` keeps the `1.0.0-beta` language baseline, includes the +`1.0.0-beta.16` 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 @@ -38,7 +38,8 @@ slice, plus the `1.0.0-beta.12` concrete vector query and prefix parity slice, the `1.0.0-beta.13` diagnostic catalog and schema policy slice, the `1.0.0-beta.14` benchmark suite catalog and metadata gate, and the `1.0.0-beta.15` reserved generic collection boundary hardening and collection -ledger. +ledger, plus the `1.0.0-beta.16` string scanning and token boundary +foundation. The language baseline supports practical local command-line, file, and loopback-network programs with: @@ -98,25 +99,36 @@ beta.9-specific text to current-beta wording while preserving diagnostic codes, schema, spans, expected/found values, hints, and output shape. It changes no source language, runtime, stdlib/API surface, benchmark metadata schema, ABI/layout behavior, or performance claim. +The `1.0.0-beta.16` string scanning and token boundary foundation adds +source facades and explicit examples for `std.string.byte_at_result`, +`std.string.slice_result`, `std.string.starts_with`, and +`std.string.ends_with`. These helpers are byte-oriented over the current +NUL-terminated runtime string representation; invalid indexes and ranges return +`err 1`, and substring allocation failure follows the existing string +allocation trap policy. This release does not promise Unicode scalar, +grapheme, display-width, or locale semantics; does not add JSON parsing, +object/array parsing, tokenizers, a language slice/view feature, or a stable +stdlib/API freeze. Still deferred before stable: executable generics, generic aliases, maps/sets, broad package registry semantics, stable Markdown schema, stable stdlib/API compatibility freeze, DNS/TLS/async networking, LSP/watch guarantees, SARIF and daemon protocols, stable `1.0.0` diagnostics freeze, re-exports/globs/hierarchical modules, mutable vectors, slice/view APIs, -iterators, new compiler-known runtime names, stable ABI and layout, +iterators, additional compiler-known runtime names, stable ABI and layout, performance claims, stable benchmark JSON metadata schema, and runtime changes for generic collections. -The next likely language slice after `1.0.0-beta.15` should continue from the -developer-experience, package, benchmark metadata, and reserved -generic/collection lanes without claiming executable generics, maps, sets, -traits, inference, monomorphization, iterators, ABI stability, runtime changes, +The next likely language slice after `1.0.0-beta.16` should continue from the +developer-experience, package, benchmark metadata, collection, or string +processing lanes without claiming executable generics, maps, sets, traits, +inference, monomorphization, iterators, ABI stability, broad runtime changes, LSP/watch protocols, SARIF/daemon protocols, registry semantics, stable Markdown schema, stable benchmark JSON schema, a stable `1.0.0` diagnostics -freeze, standard-library/API compatibility freeze, mutable vectors, slice/view -APIs, new runtime names, or performance claims until the contract and gates -are explicit. +freeze, standard-library/API compatibility freeze, mutable vectors, language +slice/view APIs, additional runtime names, Unicode/grapheme semantics, JSON +parsing, object/array parsing, or performance claims until the contract and +gates are explicit. ## Build And Test @@ -359,6 +371,23 @@ This release does not change the source language, runtime, stdlib API, diagnostic output shape, compiler CLI, LSP/watch behavior, SARIF/daemon protocols, stable Markdown schema, or stable `1.0.0` diagnostics freeze. +## 1.0.0-beta.16 String Scanning And Token Boundary Foundation + +The `1.0.0-beta.16` release adds the first explicit byte-oriented string +scanning and token-boundary helpers to the `std.string` source facade: +`byte_at_result`, `slice_result`, `starts_with`, and `ends_with`. + +The helpers operate over the current NUL-terminated runtime string bytes before +the trailing NUL. `byte_at_result` and `slice_result` return `err 1` for +ordinary invalid indexes or ranges. `slice_result` returns a runtime-owned +string on success; allocation failure may trap with the existing string +allocation policy. + +This release does not add Unicode scalar, grapheme, display-width, or locale +semantics; JSON parsing; object/array parsing; tokenizer APIs; a language +slice/view feature; mutable strings; stable ABI/layout; or a stable stdlib/API +freeze. + ## 1.0.0-beta.15 Reserved Generic Collection Boundary Hardening And Collection Ledger The `1.0.0-beta.15` release documents the current concrete collection and diff --git a/compiler/Cargo.lock b/compiler/Cargo.lock index 82172f6..aafd383 100644 --- a/compiler/Cargo.lock +++ b/compiler/Cargo.lock @@ -4,4 +4,4 @@ version = 3 [[package]] name = "glagol" -version = "1.0.0-beta.15" +version = "1.0.0-beta.16" diff --git a/compiler/Cargo.toml b/compiler/Cargo.toml index f839ffb..cc6a18b 100644 --- a/compiler/Cargo.toml +++ b/compiler/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "glagol" -version = "1.0.0-beta.15" +version = "1.0.0-beta.16" 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 a362776..3245345 100644 --- a/compiler/src/llvm.rs +++ b/compiler/src/llvm.rs @@ -26,6 +26,10 @@ pub fn emit(_file: &str, program: &CheckedProgram) -> Result { | "__glagol_fs_read_open_text_result" | "__glagol_net_tcp_read_all_result" | "__glagol_io_read_stdin_result" + | "__glagol_string_slice_result" ) { return self.emit_string_result_host_call(expr, callee, &arg_values); } @@ -1691,6 +1696,7 @@ impl FunctionGen<'_> { || callee == "__glagol_net_tcp_bound_port_result" || callee == "__glagol_net_tcp_accept_result" || callee == "__glagol_string_parse_i32_result" + || callee == "__glagol_string_byte_at_result" { return self.emit_i32_result_encoded_i64_call(expr, callee, &arg_values); } diff --git a/compiler/src/std_runtime.rs b/compiler/src/std_runtime.rs index cf62697..3f36155 100644 --- a/compiler/src/std_runtime.rs +++ b/compiler/src/std_runtime.rs @@ -68,6 +68,9 @@ const F64_PARAM: &[RuntimeType] = &[RuntimeType::F64]; const BOOL_PARAM: &[RuntimeType] = &[RuntimeType::Bool]; const STRING_PARAM: &[RuntimeType] = &[RuntimeType::String]; const STRING_STRING_PARAMS: &[RuntimeType] = &[RuntimeType::String, RuntimeType::String]; +const STRING_I32_PARAMS: &[RuntimeType] = &[RuntimeType::String, RuntimeType::I32]; +const STRING_I32_I32_PARAMS: &[RuntimeType] = + &[RuntimeType::String, RuntimeType::I32, RuntimeType::I32]; const I32_STRING_PARAMS: &[RuntimeType] = &[RuntimeType::I32, RuntimeType::String]; const VEC_I32_PARAM: &[RuntimeType] = &[RuntimeType::VecI32]; const VEC_I32_I32_PARAMS: &[RuntimeType] = &[RuntimeType::VecI32, RuntimeType::I32]; @@ -176,6 +179,34 @@ pub const FUNCTIONS: &[RuntimeFunction] = &[ return_type: RuntimeType::String, promoted: true, }, + RuntimeFunction { + source_name: "std.string.byte_at_result", + runtime_symbol: "__glagol_string_byte_at_result", + params: STRING_I32_PARAMS, + return_type: RuntimeType::ResultI32I32, + promoted: true, + }, + RuntimeFunction { + source_name: "std.string.slice_result", + runtime_symbol: "__glagol_string_slice_result", + params: STRING_I32_I32_PARAMS, + return_type: RuntimeType::ResultStringI32, + promoted: true, + }, + RuntimeFunction { + source_name: "std.string.starts_with", + runtime_symbol: "__glagol_string_starts_with", + params: STRING_STRING_PARAMS, + return_type: RuntimeType::Bool, + promoted: true, + }, + RuntimeFunction { + source_name: "std.string.ends_with", + runtime_symbol: "__glagol_string_ends_with", + params: STRING_STRING_PARAMS, + return_type: RuntimeType::Bool, + promoted: true, + }, RuntimeFunction { source_name: "std.string.parse_i32_result", runtime_symbol: "__glagol_string_parse_i32_result", @@ -747,6 +778,10 @@ const RESERVED_HELPER_SYMBOLS: &[&str] = &[ "__glagol_string_parse_u64_result", "__glagol_string_parse_f64_result", "__glagol_string_parse_bool_result", + "__glagol_string_byte_at_result", + "__glagol_string_slice_result", + "__glagol_string_starts_with", + "__glagol_string_ends_with", "__glagol_json_quote_string", "__glagol_num_u32_to_string", "__glagol_num_u64_to_string", @@ -789,7 +824,7 @@ pub fn unsupported_standard_library_call(file: &str, span: Span, source_name: &s format!("standard library call `{}` is not supported", source_name), ) .with_span(span) - .expected("std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.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") + .expected("std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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(source_name) .hint("use a promoted standard-runtime name or a legacy intrinsic alias") } diff --git a/compiler/src/test_runner.rs b/compiler/src/test_runner.rs index b3c9cc9..6fe67e1 100644 --- a/compiler/src/test_runner.rs +++ b/compiler/src/test_runner.rs @@ -759,6 +759,232 @@ fn quote_json_string_value(value: &str) -> String { quoted } +fn eval_string_byte_at_result_call( + file: &str, + expr: &TExpr, + args: &[TExpr], + locals: &mut HashMap, + functions: &HashMap<&str, &CheckedFunction>, + foreign_imports: &HashSet<&str>, + depth: usize, +) -> Result { + let Some(value) = args.first() else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.string.byte_at_result` calls", + )); + }; + let Some(index) = args.get(1) else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.string.byte_at_result` calls", + )); + }; + let value = eval_expr(file, value, locals, functions, foreign_imports, depth)?; + let index = eval_expr(file, index, locals, functions, foreign_imports, depth)?; + let Some(value) = value.as_string() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.string.byte_at_result` on non-string values", + )); + }; + let Some(index) = index.as_i32() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.string.byte_at_result` with non-i32 index", + )); + }; + let payload = usize::try_from(index) + .ok() + .and_then(|index| value.as_bytes().get(index)) + .map(|byte| i32::from(*byte)); + Ok(match payload { + Some(payload) => Value::ResultI32 { + is_ok: true, + payload, + }, + None => Value::ResultI32 { + is_ok: false, + payload: 1, + }, + }) +} + +fn eval_string_slice_result_call( + file: &str, + expr: &TExpr, + args: &[TExpr], + locals: &mut HashMap, + functions: &HashMap<&str, &CheckedFunction>, + foreign_imports: &HashSet<&str>, + depth: usize, +) -> Result { + let Some(value) = args.first() else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.string.slice_result` calls", + )); + }; + let Some(start) = args.get(1) else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.string.slice_result` calls", + )); + }; + let Some(count) = args.get(2) else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.string.slice_result` calls", + )); + }; + let value = eval_expr(file, value, locals, functions, foreign_imports, depth)?; + let start = eval_expr(file, start, locals, functions, foreign_imports, depth)?; + let count = eval_expr(file, count, locals, functions, foreign_imports, depth)?; + let Some(value) = value.as_string() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.string.slice_result` on non-string values", + )); + }; + let Some(start) = start.as_i32() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.string.slice_result` with non-i32 start", + )); + }; + let Some(count) = count.as_i32() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.string.slice_result` with non-i32 count", + )); + }; + let bytes = value.as_bytes(); + let slice = usize::try_from(start) + .ok() + .and_then(|start| { + usize::try_from(count) + .ok() + .and_then(|count| start.checked_add(count).map(|end| (start, end))) + }) + .and_then(|(start, end)| { + (start <= bytes.len() && end <= bytes.len()).then(|| &bytes[start..end]) + }); + let Some(slice) = slice else { + return Ok(Value::ResultStringI32 { + is_ok: false, + ok_payload: String::new(), + err_payload: 1, + }); + }; + let ok_payload = String::from_utf8(slice.to_vec()).map_err(|_| { + Diagnostic::new( + file, + "TestRuntimeError", + "`std.string.slice_result` produced non-UTF-8 bytes in the test runner", + ) + .with_span(expr.span) + })?; + Ok(Value::ResultStringI32 { + is_ok: true, + ok_payload, + err_payload: 0, + }) +} + +fn eval_string_starts_with_call( + file: &str, + expr: &TExpr, + args: &[TExpr], + locals: &mut HashMap, + functions: &HashMap<&str, &CheckedFunction>, + foreign_imports: &HashSet<&str>, + depth: usize, +) -> Result { + let Some(value) = args.first() else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.string.starts_with` calls", + )); + }; + let Some(prefix) = args.get(1) else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.string.starts_with` calls", + )); + }; + let value = eval_expr(file, value, locals, functions, foreign_imports, depth)?; + let prefix = eval_expr(file, prefix, locals, functions, foreign_imports, depth)?; + let Some(value) = value.as_string() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.string.starts_with` on non-string values", + )); + }; + let Some(prefix) = prefix.as_string() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.string.starts_with` with non-string prefix", + )); + }; + Ok(Value::Bool(value.as_bytes().starts_with(prefix.as_bytes()))) +} + +fn eval_string_ends_with_call( + file: &str, + expr: &TExpr, + args: &[TExpr], + locals: &mut HashMap, + functions: &HashMap<&str, &CheckedFunction>, + foreign_imports: &HashSet<&str>, + depth: usize, +) -> Result { + let Some(value) = args.first() else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.string.ends_with` calls", + )); + }; + let Some(suffix) = args.get(1) else { + return Err(unsupported_test_expr( + file, + expr, + "malformed `std.string.ends_with` calls", + )); + }; + let value = eval_expr(file, value, locals, functions, foreign_imports, depth)?; + let suffix = eval_expr(file, suffix, locals, functions, foreign_imports, depth)?; + let Some(value) = value.as_string() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.string.ends_with` on non-string values", + )); + }; + let Some(suffix) = suffix.as_string() else { + return Err(unsupported_test_expr( + file, + expr, + "`std.string.ends_with` with non-string suffix", + )); + }; + Ok(Value::Bool(value.as_bytes().ends_with(suffix.as_bytes()))) +} + fn eval_expr( file: &str, expr: &TExpr, @@ -2128,6 +2354,50 @@ fn eval_expr( }; return Ok(Value::String(format!("{}{}", left, right))); } + if runtime_symbol == "__glagol_string_byte_at_result" { + return eval_string_byte_at_result_call( + file, + expr, + args, + locals, + functions, + foreign_imports, + depth, + ); + } + if runtime_symbol == "__glagol_string_slice_result" { + return eval_string_slice_result_call( + file, + expr, + args, + locals, + functions, + foreign_imports, + depth, + ); + } + if runtime_symbol == "__glagol_string_starts_with" { + return eval_string_starts_with_call( + file, + expr, + args, + locals, + functions, + foreign_imports, + depth, + ); + } + if runtime_symbol == "__glagol_string_ends_with" { + return eval_string_ends_with_call( + file, + expr, + args, + locals, + functions, + foreign_imports, + depth, + ); + } if runtime_symbol == "__glagol_json_quote_string" { let Some(arg) = args.first() else { return Err(unsupported_test_expr( diff --git a/compiler/tests/diagnostics_contract.rs b/compiler/tests/diagnostics_contract.rs index 5aab05a..46cad82 100644 --- a/compiler/tests/diagnostics_contract.rs +++ b/compiler/tests/diagnostics_contract.rs @@ -1036,6 +1036,250 @@ const CASES: &[DiagnosticCase] = &[ "#, snapshot: "../tests/std-string-concat-unsupported-string-container.diag", }, + DiagnosticCase { + name: "std-string-byte-at-result-arity", + source: r#" +(module main) + +(fn main () -> (result i32 i32) + (std.string.byte_at_result "abc")) +"#, + snapshot: "../tests/std-string-byte-at-result-arity.diag", + }, + DiagnosticCase { + name: "std-string-byte-at-result-type", + source: r#" +(module main) + +(fn main () -> (result i32 i32) + (std.string.byte_at_result "abc" "0")) +"#, + snapshot: "../tests/std-string-byte-at-result-type.diag", + }, + DiagnosticCase { + name: "std-string-byte-at-result-context", + source: r#" +(module main) + +(fn main () -> i32 + (std.string.byte_at_result "abc" 0)) +"#, + snapshot: "../tests/std-string-byte-at-result-context.diag", + }, + DiagnosticCase { + name: "std-string-byte-at-result-bool-context", + source: r#" +(module main) + +(fn main () -> i32 + (if (std.string.byte_at_result "abc" 0) 1 0)) +"#, + snapshot: "../tests/std-string-byte-at-result-bool-context.diag", + }, + DiagnosticCase { + name: "std-string-byte-at-result-name-shadow", + source: r#" +(module main) + +(fn std.string.byte_at_result ((text string) (index i32)) -> (result i32 i32) + (err i32 i32 1)) + +(fn main () -> i32 + 0) +"#, + snapshot: "../tests/std-string-byte-at-result-name-shadow.diag", + }, + DiagnosticCase { + name: "std-string-byte-at-result-helper-shadow", + source: r#" +(module main) + +(fn __glagol_string_byte_at_result ((text string) (index i32)) -> (result i32 i32) + (err i32 i32 1)) + +(fn main () -> i32 + 0) +"#, + snapshot: "../tests/std-string-byte-at-result-helper-shadow.diag", + }, + DiagnosticCase { + name: "std-string-slice-result-arity", + source: r#" +(module main) + +(fn main () -> (result string i32) + (std.string.slice_result "abc" 0)) +"#, + snapshot: "../tests/std-string-slice-result-arity.diag", + }, + DiagnosticCase { + name: "std-string-slice-result-type", + source: r#" +(module main) + +(fn main () -> (result string i32) + (std.string.slice_result "abc" 0 "1")) +"#, + snapshot: "../tests/std-string-slice-result-type.diag", + }, + DiagnosticCase { + name: "std-string-slice-result-context", + source: r#" +(module main) + +(fn main () -> string + (std.string.slice_result "abc" 0 1)) +"#, + snapshot: "../tests/std-string-slice-result-context.diag", + }, + DiagnosticCase { + name: "std-string-slice-result-bool-context", + source: r#" +(module main) + +(fn main () -> i32 + (if (std.string.slice_result "abc" 0 1) 1 0)) +"#, + snapshot: "../tests/std-string-slice-result-bool-context.diag", + }, + DiagnosticCase { + name: "std-string-slice-result-name-shadow", + source: r#" +(module main) + +(fn std.string.slice_result ((text string) (start i32) (count i32)) -> (result string i32) + (err string i32 1)) + +(fn main () -> i32 + 0) +"#, + snapshot: "../tests/std-string-slice-result-name-shadow.diag", + }, + DiagnosticCase { + name: "std-string-slice-result-helper-shadow", + source: r#" +(module main) + +(fn __glagol_string_slice_result ((text string) (start i32) (count i32)) -> (result string i32) + (err string i32 1)) + +(fn main () -> i32 + 0) +"#, + snapshot: "../tests/std-string-slice-result-helper-shadow.diag", + }, + DiagnosticCase { + name: "std-string-starts-with-arity", + source: r#" +(module main) + +(fn main () -> bool + (std.string.starts_with "abc")) +"#, + snapshot: "../tests/std-string-starts-with-arity.diag", + }, + DiagnosticCase { + name: "std-string-starts-with-type", + source: r#" +(module main) + +(fn main () -> bool + (std.string.starts_with "abc" 1)) +"#, + snapshot: "../tests/std-string-starts-with-type.diag", + }, + DiagnosticCase { + name: "std-string-starts-with-context", + source: r#" +(module main) + +(fn main () -> i32 + (std.string.starts_with "abc" "a")) +"#, + snapshot: "../tests/std-string-starts-with-context.diag", + }, + DiagnosticCase { + name: "std-string-starts-with-name-shadow", + source: r#" +(module main) + +(fn std.string.starts_with ((text string) (prefix string)) -> bool + false) + +(fn main () -> i32 + 0) +"#, + snapshot: "../tests/std-string-starts-with-name-shadow.diag", + }, + DiagnosticCase { + name: "std-string-starts-with-helper-shadow", + source: r#" +(module main) + +(fn __glagol_string_starts_with ((text string) (prefix string)) -> bool + false) + +(fn main () -> i32 + 0) +"#, + snapshot: "../tests/std-string-starts-with-helper-shadow.diag", + }, + DiagnosticCase { + name: "std-string-ends-with-arity", + source: r#" +(module main) + +(fn main () -> bool + (std.string.ends_with "abc")) +"#, + snapshot: "../tests/std-string-ends-with-arity.diag", + }, + DiagnosticCase { + name: "std-string-ends-with-type", + source: r#" +(module main) + +(fn main () -> bool + (std.string.ends_with "abc" 1)) +"#, + snapshot: "../tests/std-string-ends-with-type.diag", + }, + DiagnosticCase { + name: "std-string-ends-with-context", + source: r#" +(module main) + +(fn main () -> i32 + (std.string.ends_with "abc" "c")) +"#, + snapshot: "../tests/std-string-ends-with-context.diag", + }, + DiagnosticCase { + name: "std-string-ends-with-name-shadow", + source: r#" +(module main) + +(fn std.string.ends_with ((text string) (suffix string)) -> bool + false) + +(fn main () -> i32 + 0) +"#, + snapshot: "../tests/std-string-ends-with-name-shadow.diag", + }, + DiagnosticCase { + name: "std-string-ends-with-helper-shadow", + source: r#" +(module main) + +(fn __glagol_string_ends_with ((text string) (suffix string)) -> bool + false) + +(fn main () -> i32 + 0) +"#, + snapshot: "../tests/std-string-ends-with-helper-shadow.diag", + }, DiagnosticCase { name: "std-string-parse-i32-result-arity", source: r#" @@ -1530,6 +1774,16 @@ const CASES: &[DiagnosticCase] = &[ "#, snapshot: "../tests/std-string-index-unsupported.diag", }, + DiagnosticCase { + name: "std-string-byte-at-unsupported", + source: r#" +(module main) + +(fn main () -> i32 + (std.string.byte_at "42" 0)) +"#, + snapshot: "../tests/std-string-byte-at-unsupported.diag", + }, DiagnosticCase { name: "std-string-slice-unsupported", source: r#" @@ -1541,6 +1795,39 @@ const CASES: &[DiagnosticCase] = &[ "#, snapshot: "../tests/std-string-slice-unsupported.diag", }, + DiagnosticCase { + name: "std-string-contains-unsupported", + source: r#" +(module main) + +(fn main () -> i32 + (std.string.contains "slovo" "lo") + 0) +"#, + snapshot: "../tests/std-string-contains-unsupported.diag", + }, + DiagnosticCase { + name: "std-string-find-result-unsupported", + source: r#" +(module main) + +(fn main () -> i32 + (std.string.find_result "slovo" "lo") + 0) +"#, + snapshot: "../tests/std-string-find-result-unsupported.diag", + }, + DiagnosticCase { + name: "std-string-split-unsupported", + source: r#" +(module main) + +(fn main () -> i32 + (std.string.split "a,b" ",") + 0) +"#, + snapshot: "../tests/std-string-split-unsupported.diag", + }, DiagnosticCase { name: "std-string-tokenize-unsupported", source: r#" diff --git a/compiler/tests/promotion_gate.rs b/compiler/tests/promotion_gate.rs index 35eeb60..9391f95 100644 --- a/compiler/tests/promotion_gate.rs +++ b/compiler/tests/promotion_gate.rs @@ -167,11 +167,25 @@ const DIAGNOSTIC_SNAPSHOTS: &[&str] = &[ "std-random-uuid-unsupported.diag", "std-result-map-unsupported.diag", "std-vec-empty-generic-unsupported.diag", + "std-string-byte-at-result-arity.diag", + "std-string-byte-at-result-bool-context.diag", + "std-string-byte-at-result-context.diag", + "std-string-byte-at-result-helper-shadow.diag", + "std-string-byte-at-result-name-shadow.diag", + "std-string-byte-at-result-type.diag", + "std-string-byte-at-unsupported.diag", "std-string-concat-arity.diag", "std-string-concat-helper-shadow.diag", "std-string-concat-result-context.diag", "std-string-concat-type.diag", "std-string-concat-unsupported-string-container.diag", + "std-string-contains-unsupported.diag", + "std-string-ends-with-arity.diag", + "std-string-ends-with-context.diag", + "std-string-ends-with-helper-shadow.diag", + "std-string-ends-with-name-shadow.diag", + "std-string-ends-with-type.diag", + "std-string-find-result-unsupported.diag", "std-string-from-i64-unsupported.diag", "std-string-index-unsupported.diag", "std-string-len-type.diag", @@ -220,7 +234,19 @@ const DIAGNOSTIC_SNAPSHOTS: &[&str] = &[ "std-string-parse-i32-whitespace-unsupported.diag", "std-string-parse-string-unsupported.diag", "std-string-scan-unsupported.diag", + "std-string-slice-result-arity.diag", + "std-string-slice-result-bool-context.diag", + "std-string-slice-result-context.diag", + "std-string-slice-result-helper-shadow.diag", + "std-string-slice-result-name-shadow.diag", + "std-string-slice-result-type.diag", "std-string-slice-unsupported.diag", + "std-string-split-unsupported.diag", + "std-string-starts-with-arity.diag", + "std-string-starts-with-context.diag", + "std-string-starts-with-helper-shadow.diag", + "std-string-starts-with-name-shadow.diag", + "std-string-starts-with-type.diag", "std-string-tokenize-unsupported.diag", "std-terminal-clear-unsupported.diag", "std-terminal-echo-unsupported.diag", @@ -1260,6 +1286,10 @@ const STANDARD_PROCESS_SOURCE_FACADE_ALPHA: &[&str] = &[ const STANDARD_STRING_SOURCE_FACADE_ALPHA: &[&str] = &[ "len", "concat", + "byte_at_result", + "slice_result", + "starts_with", + "ends_with", "parse_i32_result", "parse_i32_option", "parse_u32_result", @@ -3617,6 +3647,10 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) { "std.string.parse_i64_result", "std.string.parse_u32_result", "std.string.parse_i32_result", + "std.string.byte_at_result", + "std.string.slice_result", + "std.string.starts_with", + "std.string.ends_with", "std.string.concat", "std.string.len", ], @@ -7304,13 +7338,16 @@ fn assert_project_std_import_string_tooling_matches_fixture(project: &Path) { STANDARD_STRING_SOURCE_FACADE_ALPHA, concat!( "test \"explicit std string len concat\" ... ok\n", + "test \"explicit std string byte_at_result wrapper\" ... ok\n", + "test \"explicit std string slice_result wrapper\" ... ok\n", + "test \"explicit std string boundary wrappers\" ... ok\n", "test \"explicit std string parse result wrappers\" ... ok\n", "test \"explicit std string parse option wrappers\" ... ok\n", "test \"explicit std string parse integer fallbacks\" ... ok\n", "test \"explicit std string parse float bool fallbacks\" ... ok\n", "test \"explicit std string parse custom fallbacks\" ... ok\n", "test \"explicit std string helpers all\" ... ok\n", - "7 test(s) passed\n", + "10 test(s) passed\n", ), ); } @@ -8781,13 +8818,16 @@ fn assert_project_std_layout_local_string_tooling_matches_fixture(project: &Path test, concat!( "test \"explicit local string len concat\" ... ok\n", + "test \"explicit local string byte_at_result wrapper\" ... ok\n", + "test \"explicit local string slice_result wrapper\" ... ok\n", + "test \"explicit local string boundary wrappers\" ... ok\n", "test \"explicit local string parse result wrappers\" ... ok\n", "test \"explicit local string parse option wrappers\" ... ok\n", "test \"explicit local string parse integer fallbacks\" ... ok\n", "test \"explicit local string parse float bool fallbacks\" ... ok\n", "test \"explicit local string parse custom fallbacks\" ... ok\n", "test \"explicit local string helpers all\" ... ok\n", - "7 test(s) passed\n", + "10 test(s) passed\n", ), "std layout local string project test", ); @@ -8818,6 +8858,10 @@ fn assert_standard_string_source_fallback_helpers_alpha(project: &Path) { "std.string.parse_i64_result", "std.string.parse_u32_result", "std.string.parse_i32_result", + "std.string.byte_at_result", + "std.string.slice_result", + "std.string.starts_with", + "std.string.ends_with", "std.string.concat", "std.string.len", ], diff --git a/compiler/tests/standard_core_facade_source_search_alpha.rs b/compiler/tests/standard_core_facade_source_search_alpha.rs index 4467600..09cbfed 100644 --- a/compiler/tests/standard_core_facade_source_search_alpha.rs +++ b/compiler/tests/standard_core_facade_source_search_alpha.rs @@ -7,13 +7,16 @@ use std::{ const EXPECTED_STD_STRING_OUTPUT: &str = concat!( "test \"explicit std string len concat\" ... ok\n", + "test \"explicit std string byte_at_result wrapper\" ... ok\n", + "test \"explicit std string slice_result wrapper\" ... ok\n", + "test \"explicit std string boundary wrappers\" ... ok\n", "test \"explicit std string parse result wrappers\" ... ok\n", "test \"explicit std string parse option wrappers\" ... ok\n", "test \"explicit std string parse integer fallbacks\" ... ok\n", "test \"explicit std string parse float bool fallbacks\" ... ok\n", "test \"explicit std string parse custom fallbacks\" ... ok\n", "test \"explicit std string helpers all\" ... ok\n", - "7 test(s) passed\n", + "10 test(s) passed\n", ); const EXPECTED_STD_NUM_OUTPUT: &str = concat!( @@ -32,6 +35,10 @@ fn explicit_std_string_import_loads_repo_root_standard_source() { &[ "len", "concat", + "byte_at_result", + "slice_result", + "starts_with", + "ends_with", "parse_i32_result", "parse_i32_option", "parse_u32_result", diff --git a/compiler/tests/standard_string_scanning_beta16.rs b/compiler/tests/standard_string_scanning_beta16.rs new file mode 100644 index 0000000..cf9846d --- /dev/null +++ b/compiler/tests/standard_string_scanning_beta16.rs @@ -0,0 +1,309 @@ +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_string_scanning_beta16_lowering_shape_uses_runtime_symbols() { + let fixture = write_fixture( + "std-string-scanning-beta16-lowering", + r#" +(module main) + +(fn byte_or_code ((text string) (index i32)) -> i32 + (match (std.string.byte_at_result text index) + ((ok value) + value) + ((err code) + code))) + +(fn slice_or_empty ((text string) (start i32) (count i32)) -> string + (match (std.string.slice_result text start count) + ((ok value) + value) + ((err code) + ""))) + +(fn has_edges ((text string)) -> bool + (if (std.string.starts_with text "slo") + (std.string.ends_with text "vo") + false)) + +(fn main () -> i32 + (if (has_edges (slice_or_empty "slovo" 0 5)) + (byte_or_code "slovo" 3) + 1)) +"#, + ); + 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 rejected beta16 string scanning fixture\nstdout:\n{}\nstderr:\n{}", + stdout, + stderr + ); + assert!( + stdout.contains("declare i64 @__glagol_string_byte_at_result(ptr, i32)") + && stdout.contains("declare ptr @__glagol_string_slice_result(ptr, i32, i32)") + && stdout.contains("declare i1 @__glagol_string_starts_with(ptr, ptr)") + && stdout.contains("declare i1 @__glagol_string_ends_with(ptr, ptr)") + && stdout.contains("call i64 @__glagol_string_byte_at_result(ptr %text, i32 %index)") + && stdout.contains( + "call ptr @__glagol_string_slice_result(ptr %text, i32 %start, i32 %count)" + ) + && stdout.contains("call i1 @__glagol_string_starts_with(ptr %text, ptr @.str.") + && stdout.contains("call i1 @__glagol_string_ends_with(ptr %text, ptr @.str.") + && stdout.contains("icmp ne ptr %") + && stdout.contains("insertvalue { i1, ptr, i32 }") + && !stdout.contains("@std.string.byte_at_result") + && !stdout.contains("@std.string.slice_result") + && !stdout.contains("@std.string.starts_with") + && !stdout.contains("@std.string.ends_with"), + "LLVM output did not contain expected beta16 string runtime shape\nstdout:\n{}", + stdout + ); + assert!(stderr.is_empty(), "compiler wrote stderr:\n{}", stderr); +} + +#[test] +fn test_runner_executes_standard_string_scanning_beta16_boundaries() { + let fixture = write_fixture( + "std-string-scanning-beta16-test-runner", + r#" +(module main) + +(test "byte first ok" + (= (unwrap_ok (std.string.byte_at_result "slovo" 0)) 115)) + +(test "byte last ok" + (= (unwrap_ok (std.string.byte_at_result "slovo" 4)) 111)) + +(test "byte empty err" + (= (unwrap_err (std.string.byte_at_result "" 0)) 1)) + +(test "byte negative err" + (= (unwrap_err (std.string.byte_at_result "slovo" -1)) 1)) + +(test "byte end err" + (= (unwrap_err (std.string.byte_at_result "slovo" 5)) 1)) + +(test "slice middle ok" + (= (unwrap_ok (std.string.slice_result "slovo" 1 3)) "lov")) + +(test "slice zero count ok" + (= (unwrap_ok (std.string.slice_result "slovo" 2 0)) "")) + +(test "slice len zero ok" + (= (unwrap_ok (std.string.slice_result "slovo" 5 0)) "")) + +(test "slice full ok" + (= (unwrap_ok (std.string.slice_result "slovo" 0 5)) "slovo")) + +(test "slice negative start err" + (= (unwrap_err (std.string.slice_result "slovo" -1 1)) 1)) + +(test "slice negative count err" + (= (unwrap_err (std.string.slice_result "slovo" 1 -1)) 1)) + +(test "slice overrun err" + (= (unwrap_err (std.string.slice_result "slovo" 4 2)) 1)) + +(test "slice start past end err" + (= (unwrap_err (std.string.slice_result "slovo" 6 0)) 1)) + +(test "starts true empty" + (if (std.string.starts_with "slovo" "slo") + (std.string.starts_with "slovo" "") + false)) + +(test "starts false middle" + (= (std.string.starts_with "slovo" "ovo") false)) + +(test "ends true empty" + (if (std.string.ends_with "slovo" "ovo") + (std.string.ends_with "slovo" "") + false)) + +(test "ends false prefix" + (= (std.string.ends_with "slovo" "slo") false)) +"#, + ); + let output = run_glagol([OsStr::new("test"), fixture.as_os_str()]); + assert_success("run beta16 string scanning tests", &output); + assert_eq!( + String::from_utf8_lossy(&output.stdout), + concat!( + "test \"byte first ok\" ... ok\n", + "test \"byte last ok\" ... ok\n", + "test \"byte empty err\" ... ok\n", + "test \"byte negative err\" ... ok\n", + "test \"byte end err\" ... ok\n", + "test \"slice middle ok\" ... ok\n", + "test \"slice zero count ok\" ... ok\n", + "test \"slice len zero ok\" ... ok\n", + "test \"slice full ok\" ... ok\n", + "test \"slice negative start err\" ... ok\n", + "test \"slice negative count err\" ... ok\n", + "test \"slice overrun err\" ... ok\n", + "test \"slice start past end err\" ... ok\n", + "test \"starts true empty\" ... ok\n", + "test \"starts false middle\" ... ok\n", + "test \"ends true empty\" ... ok\n", + "test \"ends false prefix\" ... ok\n", + "17 test(s) passed\n", + ), + "beta16 string scanning test runner stdout drifted" + ); +} + +#[test] +fn standard_string_scanning_beta16_runtime_smoke_when_clang_is_available() { + let Some(clang) = find_clang() else { + eprintln!( + "skipping beta16 string scanning runtime smoke: set GLAGOL_CLANG or install clang" + ); + return; + }; + + let fixture = write_fixture( + "std-string-scanning-beta16-runtime-smoke", + r#" +(module main) + +(fn main () -> i32 + (std.io.print_i32 (unwrap_ok (std.string.byte_at_result "slovo" 3))) + (std.io.print_string (unwrap_ok (std.string.slice_result "slovo" 1 3))) + (std.io.print_bool (std.string.starts_with "slovo" "slo")) + (std.io.print_bool (std.string.ends_with "slovo" "ovo")) + (std.io.print_i32 (unwrap_err (std.string.byte_at_result "slovo" 5))) + (std.io.print_i32 (unwrap_err (std.string.slice_result "slovo" 4 2))) + 0) +"#, + ); + let compile = run_glagol([fixture.as_os_str()]); + assert_success("compile beta16 string scanning runtime smoke", &compile); + + let run = compile_and_run_with_runtime(&clang, "std-string-scanning-beta16", &compile.stdout); + assert_success("run beta16 string scanning runtime smoke", &run); + assert_eq!( + String::from_utf8_lossy(&run.stdout), + "118\nlov\ntrue\ntrue\n1\n1\n", + "beta16 string scanning runtime stdout drifted" + ); +} + +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 write_fixture(name: &str, source: &str) -> PathBuf { + let mut path = env::temp_dir(); + path.push(format!( + "glagol-standard-string-scanning-beta16-{}-{}-{}.slo", + name, + std::process::id(), + NEXT_FIXTURE_ID.fetch_add(1, Ordering::Relaxed) + )); + fs::write(&path, source).unwrap_or_else(|err| panic!("write `{}`: {}", path.display(), err)); + path +} + +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 + ); +} + +fn compile_and_run_with_runtime(clang: &Path, name: &str, ir: &[u8]) -> Output { + let manifest = Path::new(env!("CARGO_MANIFEST_DIR")); + let temp_dir = env::temp_dir().join(format!( + "glagol-standard-string-scanning-beta16-{}-{}", + std::process::id(), + NEXT_FIXTURE_ID.fetch_add(1, Ordering::Relaxed) + )); + fs::create_dir_all(&temp_dir) + .unwrap_or_else(|err| panic!("create `{}`: {}", temp_dir.display(), err)); + + let ir_path = temp_dir.join(format!("{}.ll", name)); + let exe_path = temp_dir.join(name); + fs::write(&ir_path, ir).unwrap_or_else(|err| panic!("write `{}`: {}", ir_path.display(), err)); + + let runtime = manifest.join("../runtime/runtime.c"); + let mut clang_command = Command::new(clang); + clang_command + .arg(&runtime) + .arg(&ir_path) + .arg("-o") + .arg(&exe_path) + .current_dir(manifest); + configure_clang_runtime_env(&mut clang_command, clang); + let clang_output = clang_command + .output() + .unwrap_or_else(|err| panic!("run `{}`: {}", clang.display(), err)); + assert_success("clang beta16 string scanning runtime smoke", &clang_output); + + Command::new(&exe_path) + .output() + .unwrap_or_else(|err| panic!("run `{}`: {}", exe_path.display(), err)) +} + +fn find_clang() -> Option { + if let Some(path) = env::var_os("GLAGOL_CLANG").filter(|value| !value.is_empty()) { + return Some(PathBuf::from(path)); + } + + let hermetic_clang = PathBuf::from("/tmp/glagol-clang-root/usr/bin/clang"); + if hermetic_clang.is_file() { + return Some(hermetic_clang); + } + + find_on_path("clang") +} + +fn find_on_path(program: &str) -> Option { + let path = env::var_os("PATH")?; + env::split_paths(&path) + .map(|dir| dir.join(program)) + .find(|candidate| candidate.is_file()) +} + +fn configure_clang_runtime_env(command: &mut Command, clang: &Path) { + if !clang.starts_with("/tmp/glagol-clang-root") { + return; + } + + let root = Path::new("/tmp/glagol-clang-root"); + let lib64 = root.join("usr/lib64"); + let lib = root.join("usr/lib"); + let mut paths = vec![lib64, lib]; + + if let Some(existing) = env::var_os("LD_LIBRARY_PATH") { + paths.extend(env::split_paths(&existing)); + } + + let joined = env::join_paths(paths).expect("join LD_LIBRARY_PATH"); + command.env("LD_LIBRARY_PATH", joined); +} diff --git a/compiler/tests/standard_string_source_fallback_helpers_alpha.rs b/compiler/tests/standard_string_source_fallback_helpers_alpha.rs index 1289b9a..05e906d 100644 --- a/compiler/tests/standard_string_source_fallback_helpers_alpha.rs +++ b/compiler/tests/standard_string_source_fallback_helpers_alpha.rs @@ -7,18 +7,25 @@ use std::{ const EXPECTED_TEST_OUTPUT: &str = concat!( "test \"explicit local string len concat\" ... ok\n", + "test \"explicit local string byte_at_result wrapper\" ... ok\n", + "test \"explicit local string slice_result wrapper\" ... ok\n", + "test \"explicit local string boundary wrappers\" ... ok\n", "test \"explicit local string parse result wrappers\" ... ok\n", "test \"explicit local string parse option wrappers\" ... ok\n", "test \"explicit local string parse integer fallbacks\" ... ok\n", "test \"explicit local string parse float bool fallbacks\" ... ok\n", "test \"explicit local string parse custom fallbacks\" ... ok\n", "test \"explicit local string helpers all\" ... ok\n", - "7 test(s) passed\n", + "10 test(s) passed\n", ); const STANDARD_STRING_SOURCE_FALLBACK_HELPERS_ALPHA: &[&str] = &[ "len", "concat", + "byte_at_result", + "slice_result", + "starts_with", + "ends_with", "parse_i32_result", "parse_i32_option", "parse_u32_result", @@ -100,6 +107,10 @@ fn assert_local_string_fixture_is_source_authored(project: &Path) { "std.string.parse_u64_result", "std.string.parse_i32_result", "std.string.parse_u32_result", + "std.string.byte_at_result", + "std.string.slice_result", + "std.string.starts_with", + "std.string.ends_with", "std.string.concat", "std.string.len", ] { diff --git a/docs/POST_BETA_ROADMAP.md b/docs/POST_BETA_ROADMAP.md index 3f6f156..d1ec9c0 100644 --- a/docs/POST_BETA_ROADMAP.md +++ b/docs/POST_BETA_ROADMAP.md @@ -188,7 +188,7 @@ 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 +has later byte-oriented string scanning helpers. 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 @@ -455,6 +455,41 @@ duplication to justify generic collection planning, but the public contract needs an explicit boundary ledger before executable generic, map, set, iterator, mutable-vector, or slice/view semantics are promoted. +### 16. String Scanning And Token Boundary Foundation + +Goal: add the first byte-oriented string scanning and token-boundary helpers +without promoting Unicode/grapheme semantics, JSON parsing, or language +slice/view syntax. + +Work: + +- add `byte_at_result`, `slice_result`, `starts_with`, and `ends_with` to + `lib/std/string.slo` +- mirror those source facades in the explicit local `std-layout-local-string` + fixture +- cover both local and explicit `std.string` imports with examples for success + and ordinary failure cases +- document byte-oriented behavior over current NUL-terminated runtime strings +- require invalid indexes and ranges to return `err 1` +- keep allocation failure on substring creation aligned with the existing + string allocation trap policy +- keep Unicode scalar/grapheme/display-width semantics, JSON parsing, + object/array parsing, tokenizer objects, language slice/view features, + mutable strings, stable ABI/layout, and stable API freeze out of scope + +Released in `1.0.0-beta.16`: `std.string` now exposes source facades and +examples for byte access, substring extraction, and prefix/suffix checks: +`byte_at_result`, `slice_result`, `starts_with`, and `ends_with`. The release is +byte-oriented over the current runtime string representation and uses `err 1` +for ordinary invalid indexes/ranges. It does not add Unicode/grapheme +semantics, JSON parsing, object/array parsing, tokenizer objects, language +slice/view features, mutable strings, stable ABI/layout, or a stable +stdlib/API freeze. + +Why sixteenth: JSON text construction and process/file/network helpers can +produce useful strings, but parsers and tokenizers need a smaller byte-boundary +foundation before richer string or data-interchange APIs are credible. + ## Stable `1.0.0` Gate Slovo should not become stable until all of these are true: diff --git a/docs/compiler/RELEASE_NOTES.md b/docs/compiler/RELEASE_NOTES.md index b0c034e..304d869 100644 --- a/docs/compiler/RELEASE_NOTES.md +++ b/docs/compiler/RELEASE_NOTES.md @@ -10,11 +10,46 @@ integration/readiness release, not the first real beta. ## Unreleased -Next scoped Glagol work is expected to continue after the `1.0.0-beta.15` -reserved generic collection boundary hardening and collection ledger update. +Next scoped Glagol work is expected to continue after the `1.0.0-beta.16` +string scanning and token-boundary runtime foundation. No unreleased compiler scope is committed here yet. +## 1.0.0-beta.16 + +Release label: `1.0.0-beta.16` + +Release date: 2026-05-22 + +Release state: string scanning and token-boundary runtime foundation + +### Summary + +The beta.16 compiler/runtime contract promotes a byte-oriented string +scanning foundation for source-authored stdlib wrappers without claiming +Unicode, grapheme, tokenizer, parser, or stable ABI behavior. + +- Bump the `glagol` compiler package version to `1.0.0-beta.16`. +- Add promoted compiler-known runtime names for `std.string.byte_at_result`, + `std.string.slice_result`, `std.string.starts_with`, and + `std.string.ends_with`. +- Lower `byte_at_result` through the existing encoded `result i32 i32` shape + and `slice_result` through the existing nullable string-result host-call + shape. Invalid indexes or ranges return `err 1`; slice allocation failure + follows the existing string allocation trap. +- Add hosted C runtime implementations over current null-terminated runtime + strings and matching test-runner behavior for deterministic Slovo tests. +- Extend diagnostics, facade project checks, and release-gate coverage for + the beta16 string-scanning boundary while keeping richer scanning and token + APIs unsupported. + +### Explicit Deferrals + +This release does not implement Unicode or grapheme semantics, a JSON parser, +tokenizers, split/find/contains helpers, stable string ABI/layout, stable +allocation ownership rules, or a stable standard-library compatibility +contract. + ## 1.0.0-beta.15 Release label: `1.0.0-beta.15` diff --git a/docs/compiler/ROADMAP.md b/docs/compiler/ROADMAP.md index c762836..f79ab2b 100644 --- a/docs/compiler/ROADMAP.md +++ b/docs/compiler/ROADMAP.md @@ -22,8 +22,8 @@ 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.15`, released on 2026-05-22 as a reserved generic -collection boundary hardening and collection ledger update. It keeps the +Current stage: `1.0.0-beta.16`, released on 2026-05-22 as a string scanning +and token-boundary runtime foundation. 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, @@ -67,15 +67,20 @@ reserved diagnostics to stage-neutral current-beta text, and gates the collection ledger for generic functions, parameterized aliases, generic type parameters, generic vector spelling, map/set types, `std.vec.empty`, and `std.result.map` across check, fmt, and project paths without promoting those -surfaces. +surfaces. The beta.16 compiler/runtime slice adds byte-oriented +`std.string.byte_at_result`, `std.string.slice_result`, +`std.string.starts_with`, and `std.string.ends_with` over current +null-terminated runtime strings, with invalid indexes/ranges returning +`err 1`, without Unicode/grapheme semantics, tokenizer/parser claims, or +stable ABI/layout commitments. -Next stage target: post-`1.0.0-beta.15` developer-experience, package, and +Next stage target: post-`1.0.0-beta.16` developer-experience, package, and collection/generic planning. Generic vectors, generic collections, maps, sets, generic stdlib dispatch, runtime collection changes, collection unification, stable human diagnostic text, stable Markdown schema, LSP/watch protocols, SARIF/daemon protocols, re-exports/globs/hierarchical modules, registry -semantics, mutable vectors, slice/view APIs, new runtime names, iterators, -performance claims, ABI/layout stability, and a stable stdlib/API +semantics, mutable vectors, stable slice/view APIs, tokenizers, JSON parsing, +iterators, performance claims, ABI/layout stability, and a stable stdlib/API compatibility freeze remain unimplemented until a later scoped contract promotes them explicitly. diff --git a/docs/language/RELEASE_NOTES.md b/docs/language/RELEASE_NOTES.md index 4b02f76..37fd0c6 100644 --- a/docs/language/RELEASE_NOTES.md +++ b/docs/language/RELEASE_NOTES.md @@ -8,7 +8,7 @@ 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.15`, published on 2026-05-22. It keeps the +The current release is `1.0.0-beta.16`, 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 @@ -25,12 +25,45 @@ collection alias unification and generic reservation slice from `1.0.0-beta.12`, and the diagnostic catalog and schema policy slice from `1.0.0-beta.13`, plus the benchmark suite catalog and metadata gate from `1.0.0-beta.14`, plus the reserved generic collection boundary hardening and -collection ledger from `1.0.0-beta.15`. +collection ledger from `1.0.0-beta.15`, plus the string scanning and token +boundary foundation from `1.0.0-beta.16`. ## Unreleased No unreleased language scope is committed here yet. +## 1.0.0-beta.16 + +Release label: `1.0.0-beta.16` + +Release name: String Scanning And Token Boundary Foundation + +Release date: 2026-05-22 + +Status: released beta string scanning and token-boundary foundation on the +`1.0.0-beta` language baseline. + +`1.0.0-beta.16` adds the first explicit string scanning/token-boundary helper +surface: + +- `std.string.byte_at_result : (string, i32) -> (result i32 i32)` +- `std.string.slice_result : (string, i32, i32) -> (result string i32)` +- `std.string.starts_with : (string, string) -> bool` +- `std.string.ends_with : (string, string) -> bool` +- matching `lib/std/string.slo` exports and explicit local/`std.string` + examples + +The helpers are byte-oriented over the current NUL-terminated runtime string +representation and observe bytes before the trailing NUL. Invalid byte indexes +or ranges return `err 1`. `slice_result` returns a runtime-owned string on +success; allocation failure may follow the existing string allocation trap +policy. + +This release does not add Unicode scalar, grapheme, display-width, or locale +semantics; JSON parsing; object or array parsing; tokenizer/scanner objects; a +language slice/view feature; mutable strings; string containers; stable +ABI/layout; or a stable stdlib/API freeze. + ## 1.0.0-beta.15 Release label: `1.0.0-beta.15` diff --git a/docs/language/ROADMAP.md b/docs/language/ROADMAP.md index d1821c3..4af4cfd 100644 --- a/docs/language/ROADMAP.md +++ b/docs/language/ROADMAP.md @@ -10,66 +10,50 @@ 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.15`, released on 2026-05-22 as a post-beta -reserved generic collection boundary hardening and collection ledger. 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` +Current stage: `1.0.0-beta.16`, released on 2026-05-22 as a post-beta string +scanning and token boundary foundation. 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, plus a narrow `std.json` source facade for compact JSON text -construction, plus top-level module-local transparent aliases for supported -concrete target types, plus local alias use inside the current concrete vector, -option, and result facades, plus a generated standard-library API catalog that -lists exact exported helper signatures with module-local aliases normalized to -concrete public types, plus `glagol symbols` deterministic source metadata for -files, projects, and workspaces, plus -`glagol doc -o ` public API sections for local -packages/modules with exact exported function signatures, exported struct -fields, exported enum variants/payload types, non-export filtering, and -module-local alias normalization, plus source-authored concrete vector helper -parity: `std.vec_i64` gains `count_of`, `starts_with`, `without_prefix`, -`ends_with`, and `without_suffix`, and `std.vec_f64` gains `count_of`, plus -[`docs/language/DIAGNOSTICS.md`](DIAGNOSTICS.md) as the beta -`slovo.diagnostic` version `1` policy and current golden diagnostic code -catalog, plus [`../../benchmarks/README.md`](../../benchmarks/README.md) as -the beta-scoped benchmark suite catalog documenting the current suite -inventory, `python3 benchmarks/runner.py --suite-list`, and -`python3 benchmarks/runner.py --suite-list --json`. Benchmark timings remain -local-machine evidence only, and suite-list JSON is beta tooling metadata -rather than a stable public schema. The current stage also adds -[`COLLECTIONS.md`](COLLECTIONS.md) as the collection/value-family ledger. It -links to the generated [`STDLIB_API.md`](STDLIB_API.md) catalog for exact -signatures, records design pressure from duplicated concrete -vector/option/result families, defines prerequisites for future executable -generics, generic aliases, maps, sets, iterators, mutable vectors, and -slice/view APIs, and treats current unsupported diagnostics as boundaries -rather than behavior changes. It also rewords affected reserved-boundary -diagnostic messages away from beta.9-specific text while preserving diagnostic -codes, schema, spans, expected/found values, hints, and output shape. -`1.0.0-beta.15` changes no source language, runtime, stdlib/API surface, -diagnostic output shape/codes/schema, benchmark metadata schema, ABI/layout -behavior, or performance claim. JSON parsing, -recursive JSON values, executable generics, generic aliases, parameterized -aliases, cross-module alias visibility, maps/sets, traits, inference, -monomorphization, iterators, runtime changes for generic collections, DNS, -TLS, UDP, async IO, non-loopback binding, HTTP frameworks, rich host-error -ADTs, stable ABI/layout, stable Markdown schema, stable stdlib/API -compatibility freeze, LSP/watch, SARIF/daemon protocols, stable `1.0.0` -diagnostics freeze, re-exports/globs/hierarchical modules, mutable vectors, -slice/view APIs, new runtime names, timing publication, performance claims, -stable benchmark JSON schema, and package registry semantics remain deferred. +discipline release, the `1.0.0-beta.6` loopback networking foundation, +`1.0.0-beta.7` compact JSON text construction, `1.0.0-beta.8` concrete type +aliases, `1.0.0-beta.9` collection alias unification and generic reservation, +`1.0.0-beta.10` API discovery, `1.0.0-beta.11` local package API +documentation, `1.0.0-beta.12` concrete vector helper parity, +`1.0.0-beta.13` diagnostic catalog and schema policy, `1.0.0-beta.14` +benchmark suite catalog and metadata gate, and `1.0.0-beta.15` reserved +generic collection boundary hardening and collection ledger. -Next stage target: continue after `1.0.0-beta.15` from developer-experience, -package, benchmark metadata, and reserved generic/map/set planning without +The current stage adds `std.string` source facades and examples for +`byte_at_result`, `slice_result`, `starts_with`, and `ends_with`. These helpers +are byte-oriented over the current NUL-terminated runtime string +representation; invalid indexes and ranges return `err 1`, and substring +allocation failure may use the existing string allocation trap policy. +`1.0.0-beta.16` does not add Unicode scalar, grapheme, display-width, or locale +semantics; JSON parsing; object/array parsing; tokenizer objects; language +slice/view syntax; mutable strings; stable ABI/layout; performance claims; or a +stable stdlib/API freeze. + +JSON parsing, recursive JSON values, executable generics, generic aliases, +parameterized aliases, cross-module alias visibility, maps/sets, traits, +inference, monomorphization, iterators, runtime changes for generic +collections, DNS, TLS, UDP, async IO, non-loopback binding, HTTP frameworks, +rich host-error ADTs, stable ABI/layout, stable Markdown schema, stable +stdlib/API compatibility freeze, LSP/watch, SARIF/daemon protocols, stable +`1.0.0` diagnostics freeze, re-exports/globs/hierarchical modules, mutable +vectors, language slice/view APIs, additional runtime names, Unicode/grapheme +string semantics, timing publication, performance claims, stable benchmark JSON +schema, and package registry semantics remain deferred. + +Next stage target: continue after `1.0.0-beta.16` from developer-experience, +package, benchmark metadata, collection, or string-processing planning without claiming executable generics, an LSP/watch protocol, SARIF/daemon protocol, stable Markdown schema, registry semantics, stable benchmark JSON schema, -stable `1.0.0` diagnostics freeze, or stable standard-library/API -compatibility freeze, mutable vectors, slice/view APIs, new runtime names, -performance claims, maps/sets, or iterators until the exact scope is frozen -from the manifest and roadmap. +stable `1.0.0` diagnostics freeze, stable standard-library/API compatibility +freeze, mutable vectors, language slice/view APIs, additional runtime names, +Unicode/grapheme semantics, JSON parsing, maps/sets, iterators, or performance +claims until the exact scope is frozen from the manifest and roadmap. 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 f8ff028..18a7fba 100644 --- a/docs/language/SPEC-v1.md +++ b/docs/language/SPEC-v1.md @@ -6,8 +6,9 @@ foundation update, `1.0.0-beta.10` developer-experience API discovery update, `1.0.0-beta.11` local package API documentation update, and `1.0.0-beta.12` concrete vector query and prefix parity update, and `1.0.0-beta.13` diagnostic catalog and schema policy update, and `1.0.0-beta.14` benchmark -suite catalog and metadata gate, and `1.0.0-beta.15` reserved generic -collection boundary hardening and collection ledger. The language contract +suite catalog and metadata gate, `1.0.0-beta.15` reserved generic collection +boundary hardening and collection ledger, and `1.0.0-beta.16` string scanning +and token boundary foundation. The language contract integrates promoted language slices through `exp-125` and the historical publication baseline through `exp-123`. `1.0.0-beta` is the first real general-purpose @@ -184,6 +185,16 @@ Current v1 release surface and explicit experimental targets: ABI/layout, performance-claim, or stable stdlib/API change; affected reserved-boundary messages are reworded from beta.9-specific text to current-beta wording +- `1.0.0-beta.16` string scanning and token boundary target: + `std.string.byte_at_result`, `std.string.slice_result`, + `std.string.starts_with`, and `std.string.ends_with` provide byte-oriented + scanning helpers over the current NUL-terminated runtime string + representation; invalid indexes and ranges return `err 1`, substring + allocation failure may follow the existing string allocation trap policy, and + this target does not add Unicode/grapheme/display-width semantics, JSON + parsing, object/array parsing, tokenizer objects, language slice/view syntax, + mutable strings, stable ABI/layout, performance claims, or a stable + stdlib/API freeze - `exp-1` owned runtime strings: compiler-known `std.string.concat` accepts two `string` values and returns an immutable runtime-owned `string`; existing string equality, length, printing, locals, parameters, returns, and calls work @@ -1472,6 +1483,36 @@ target explicitly does not add executable generics, generic aliases, parameterized aliases, maps, sets, generic stdlib dispatch, iterators, mutable vectors, slice/view APIs, new runtime names, or a stable stdlib/API freeze. +### 4.4.13 Post-Beta String Scanning And Token Boundary Foundation + +Status: released in `1.0.0-beta.16` as a byte-oriented string scanning and +token-boundary foundation over the existing runtime string representation. + +`1.0.0-beta.16` adds these `std.string` helpers: + +- `byte_at_result ((value string) (index i32)) -> (result i32 i32)` +- `slice_result ((value string) (start i32) (count i32)) -> (result string i32)` +- `starts_with ((value string) (prefix string)) -> bool` +- `ends_with ((value string) (suffix string)) -> bool` + +The helpers operate on bytes before the trailing NUL in the current +NUL-terminated runtime string representation. `byte_at_result` returns `ok` +with the byte value as `i32` for valid zero-based byte indexes and returns +`err 1` for invalid indexes. `slice_result` returns `ok` with a runtime-owned +string for valid byte ranges and returns `err 1` for invalid ranges. Allocation +failure while creating the substring may follow the existing string allocation +trap policy. + +`starts_with` and `ends_with` compare byte prefixes and suffixes. Empty prefixes +and empty suffixes match. No helper performs Unicode normalization, grapheme +segmentation, display-width measurement, locale-sensitive matching, or +case-folding. + +This target does not add JSON parsing, object/array parsing, tokenizer or +scanner objects, language slice/view syntax or borrowed substring views, +mutable strings, string containers, stable runtime ABI/layout, performance +claims, or a stable standard-library/API freeze. + ## 4.5 v2.0.0-beta.1 Experimental Integration Readiness Status: current experimental Slovo-side release contract, released 2026-05-17. @@ -5059,7 +5100,9 @@ owned-runtime-string compiler-supported fixture. exp-13 adds `examples/supported/string-parse-i32-result.slo` as the first string parse result compiler-supported fixture. exp-34 adds `examples/supported/string-parse-bool-result.slo` for the exact lowercase bool -parse result slice. +parse result slice. `1.0.0-beta.16` adds byte-oriented string scanning and +token-boundary helpers through the `std.string` source facade and explicit +examples. ### 8.1 Goal @@ -5093,6 +5136,9 @@ The promoted slice supports: `(result i32 i32)` value from an entire ASCII decimal signed `i32` string - exp-34 released `std.string.parse_bool_result`, returning `(result bool i32)` for exact lowercase `true`/`false` parsing with `err 1` ordinary failures +- `1.0.0-beta.16` byte-oriented string helpers: + `std.string.byte_at_result`, `std.string.slice_result`, + `std.string.starts_with`, and `std.string.ends_with` Everything else in the string family remains deferred until separately specified, implemented, diagnosed, formatted, and tested. @@ -5164,6 +5210,29 @@ locals, parameters, returns, and calls returning `string`. No import is required, no legacy alias is introduced, and no user-visible allocation or deallocation form is exposed. +`1.0.0-beta.16` adds byte-oriented string scanning and token-boundary helpers: + +```slo +(std.string.byte_at_result "slovo" 0) +(std.string.slice_result "slovo" 1 3) +(std.string.starts_with "slovo" "slo") +(std.string.ends_with "slovo" "ovo") +``` + +`std.string.byte_at_result` has one `string` argument and one `i32` index. It +returns `ok byte` for valid zero-based byte indexes before the trailing NUL and +`err 1` for ordinary invalid indexes. + +`std.string.slice_result` has one `string` argument, one `i32` start byte, and +one `i32` byte count. It returns `ok text` for a valid range and `err 1` for an +ordinary invalid range. The successful result is runtime-owned and immutable. +Allocation failure may trap with the existing string allocation failure policy. + +`std.string.starts_with` and `std.string.ends_with` compare byte prefixes and +suffixes and return `bool`. Empty prefixes and suffixes match. These helpers do +not perform Unicode normalization, grapheme segmentation, display-width +measurement, locale-sensitive matching, or case-folding. + v1.2 promotes bool printing through the legacy alias: ```slo @@ -5242,14 +5311,18 @@ Promoted uses of `string` values: - operands to `=` when both operands check as `string` - argument to `string_len` or `std.string.len` - exp-1 arguments to and result from `std.string.concat` +- `1.0.0-beta.16` byte indexes and byte ranges through + `std.string.byte_at_result` and `std.string.slice_result` +- `1.0.0-beta.16` prefix and suffix byte comparisons through + `std.string.starts_with` and `std.string.ends_with` Still deferred: - string ordering or comparison other than equality - string values inside arrays or vectors -- slices or borrowed substring views +- language slice/view syntax or borrowed substring views - concatenation beyond exp-1 `std.string.concat` -- indexing +- unchecked indexing or character/grapheme indexing - ownership or lifetime annotations - user-defined runtime bindings involving `string` @@ -5276,6 +5349,11 @@ Required lowering shape: - exp-1 `std.string.concat` lowers to a runtime-owned immutable string allocation, byte copy, and trailing terminator write; allocation failure traps with `slovo runtime error: string allocation failed` +- `1.0.0-beta.16` `std.string.byte_at_result`, + `std.string.slice_result`, `std.string.starts_with`, and + `std.string.ends_with` operate over bytes before the trailing NUL; invalid + byte indexes/ranges return `err 1`, and successful `slice_result` returns a + runtime-owned immutable string - since embedded NUL is not promoted, printing observes the whole decoded literal and equality/length observe the whole decoded value @@ -5354,9 +5432,10 @@ as `string`. `string_len` and `print_bool` use the same compact call style as other promoted intrinsics. v1.5 `std.io.print_*` and `std.string.len` calls use the same compact call style. exp-1 `std.string.concat` uses the same compact call style and remains inline when nested in `std.io.print_string`, -`std.string.len`, equality, local initializers, returns, and user calls. The -formatter must preserve the decoded literal meaning when re-emitting the -current supported escapes. +`std.string.len`, equality, local initializers, returns, and user calls. +`1.0.0-beta.16` string scanning helpers use the same compact call style. The +formatter must preserve the decoded literal meaning when re-emitting the current +supported escapes. ### 8.7 Diagnostics @@ -5397,8 +5476,9 @@ Required promoted-boundary diagnostics: - string ordering/comparison other than equality, string containers beyond the current direct struct fields, current fixed string arrays, current direct fixed-array struct fields, and current concrete option/result families, - slices, concatenation beyond exp-1 - `std.string.concat`, indexing, mutation, user-visible allocation, + language slice/view syntax, concatenation beyond exp-1 + `std.string.concat`, unchecked indexing, character/grapheme indexing, + mutation, user-visible allocation, user-visible deallocation, and user-defined runtime bindings must remain unsupported with structured diagnostics or explicit backend-feature diagnostics; they must not reach a backend panic @@ -6019,7 +6099,8 @@ promises remain deferred until a future spec explicitly promotes them. host error ADTs, stdin APIs beyond exp-12, parsing APIs beyond exp-13 `std.string.parse_i32_result`, exp-25 `std.string.parse_i64_result`, exp-28 `std.string.parse_f64_result`, and exp-34 exact lowercase - `std.string.parse_bool_result`, + `std.string.parse_bool_result`, string scanning/tokenizing APIs beyond + `1.0.0-beta.16` byte access, substring, and prefix/suffix helpers, result helper payload families beyond the explicitly listed `(result i32 i32)`, `(result i64 i32)`, `(result string i32)`, exp-28 returned `(result f64 i32)`, and exp-34 returned `(result bool i32)` @@ -6087,11 +6168,13 @@ promises remain deferred until a future spec explicitly promotes them. exp-13 `std.string.parse_i32_result`, exp-25 `std.string.parse_i64_result`, and exp-28 `std.string.parse_f64_result`, plus exp-34 exact lowercase - `std.string.parse_bool_result`, indexing, slicing, string containers beyond + `std.string.parse_bool_result`, unchecked indexing, character/grapheme + indexing, language slice/view syntax, string containers beyond the current direct struct fields, current fixed string arrays, current direct fixed-array struct fields, and current concrete option/result - families, user-visible string allocation or deallocation, Unicode length or - digit semantics, and stable string ABI/layout + families, user-visible string allocation or deallocation, Unicode length, + grapheme, display-width, locale, or digit semantics, JSON parsing, + object/array parsing, and stable string ABI/layout - pointer types, allocation, deallocation, load, store, pointer arithmetic, reinterpretation, unchecked indexing, raw memory operations, and FFI - stable ABI and stable layout promises diff --git a/docs/language/STANDARD_RUNTIME.md b/docs/language/STANDARD_RUNTIME.md index e148967..800522c 100644 --- a/docs/language/STANDARD_RUNTIME.md +++ b/docs/language/STANDARD_RUNTIME.md @@ -1,6 +1,7 @@ # Slovo Standard Runtime Catalog -Status: standard-runtime catalog through exp-104 over the released exp-14 +Status: standard-runtime catalog through exp-104 plus the post-beta +`1.0.0-beta.16` string scanning foundation over the released exp-14 conformance baseline. The latest Slovo experimental alpha release is `exp-104`, Standard Vec Bool Baseline Alpha. exp-29, exp-30, exp-32, exp-33, and exp-35 through exp-93 add no compiler-known `std.*` names; @@ -31,8 +32,15 @@ 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. +deterministic compact JSON string quoting before later byte-oriented string +scanning helpers, maps, or recursive JSON values are available. + +The `1.0.0-beta.16` string scanning and token-boundary foundation release adds +byte-oriented `std.string` runtime helpers behind the source facade. The helpers +operate over bytes before the trailing NUL in the current runtime string +representation, return `err 1` for ordinary invalid indexes or ranges, and do +not define Unicode scalar, grapheme, display-width, locale, JSON parser, +object/array parser, language slice/view, or stable API semantics. The exp-era catalog is closed to names promoted through exp-104. exp-29, exp-30, exp-32, exp-33, and exp-35 through exp-93 add no new standard-runtime @@ -81,6 +89,10 @@ 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.string.byte_at_result` | `(string, i32) -> (result i32 i32)` | `1.0.0-beta.16` | `examples/projects/std-layout-local-string` | Returns `ok byte` for a valid zero-based byte index before the trailing NUL, or `err 1` for an invalid index. | Uses existing standard-runtime usage recording if present; no schema change. | Character/grapheme indexing, unchecked indexing, Unicode scalar values, stable string ABI/layout. | +| `std.string.slice_result` | `(string, i32, i32) -> (result string i32)` | `1.0.0-beta.16` | `examples/projects/std-layout-local-string` | Returns `ok text` for a valid byte range before the trailing NUL, or `err 1` for an invalid range; allocation failure may trap with the existing string allocation policy. | Uses existing standard-runtime usage recording if present; no schema change. | Borrowed substring views, language slice/view syntax, Unicode/grapheme slicing, stable string ABI/layout/ownership. | +| `std.string.starts_with` | `(string, string) -> bool` | `1.0.0-beta.16` | `examples/projects/std-layout-local-string` | Returns whether the first string starts with the prefix bytes; the empty prefix matches. | Uses existing standard-runtime usage recording if present; no schema change. | Locale-sensitive matching, case folding, Unicode normalization, tokenizer/parser APIs, stable string ABI/layout. | +| `std.string.ends_with` | `(string, string) -> bool` | `1.0.0-beta.16` | `examples/projects/std-layout-local-string` | Returns whether the first string ends with the suffix bytes; the empty suffix matches. | Uses existing standard-runtime usage recording if present; no schema change. | Locale-sensitive matching, case folding, Unicode normalization, tokenizer/parser APIs, 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 current concrete vector families, 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. | @@ -183,8 +195,10 @@ integer-to-string calls, the exp-26 f64-to-string call, and the released `std.string.parse_i64_result` / `std.string.parse_f64_result` / `std.string.parse_bool_result` result calls, bool parsing beyond exact -lowercase `true`/`false`, string/bytes parse, -underscores, rich parse errors, Unicode digit parsing, f64 containers, +lowercase `true`/`false`, string scanning/tokenizing APIs beyond +`1.0.0-beta.16` byte access, substring, and prefix/suffix helpers, +string/bytes parse, underscores, rich parse errors, Unicode digit parsing, +f64 containers, writable resource handles, binary IO, directory handles, directory enumeration, recursive filesystem operations, process handles, sockets, async resource handling, platform-specific host error codes, rich host-error ADTs, diff --git a/docs/language/STDLIB_API.md b/docs/language/STDLIB_API.md index 4c1824b..818d180 100644 --- a/docs/language/STDLIB_API.md +++ b/docs/language/STDLIB_API.md @@ -6,7 +6,7 @@ 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.15`; future releases may mark new helpers this way before they graduate. +- `experimental`: not used for exported `lib/std` helpers in `1.0.0-beta.16`; 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 API discovery aid, not a stable `1.0.0` standard-library freeze. @@ -16,7 +16,7 @@ Only exported `(fn ...)` helpers are listed; `(type ...)` aliases and non-export ## Summary - Modules: 19 -- Exported helper signatures: 578 +- Exported helper signatures: 582 - Exported type aliases omitted: 0 - Default tier: `beta-supported` @@ -479,10 +479,14 @@ Only exported `(fn ...)` helpers are listed; `(type ...)` aliases and non-export - Path: `lib/std/string.slo` - Tier: `beta-supported` -- Exported helper signatures: 26 +- Exported helper signatures: 30 - `len ((value string)) -> i32` - `concat ((left string) (right string)) -> string` +- `byte_at_result ((value string) (index i32)) -> (result i32 i32)` +- `slice_result ((value string) (start i32) (count i32)) -> (result string i32)` +- `starts_with ((value string) (prefix string)) -> bool` +- `ends_with ((value string) (suffix string)) -> bool` - `parse_i32_result ((value string)) -> (result i32 i32)` - `parse_i32_option ((value string)) -> (option i32)` - `parse_u32_result ((value string)) -> (result u32 i32)` diff --git a/docs/language/examples/projects/std-import-string/src/main.slo b/docs/language/examples/projects/std-import-string/src/main.slo index 5ae4c9f..74b36c2 100644 --- a/docs/language/examples/projects/std-import-string/src/main.slo +++ b/docs/language/examples/projects/std-import-string/src/main.slo @@ -1,6 +1,6 @@ (module main) -(import std.string (len concat parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) +(import std.string (len concat byte_at_result slice_result starts_with ends_with parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) (fn imported_string_concat () -> string (concat "slo" "vo")) @@ -8,6 +8,37 @@ (fn imported_string_len_concat_score () -> i32 (+ (len (imported_string_concat)) 37)) +(fn imported_string_byte_at_ok () -> bool + (if (= (unwrap_ok (byte_at_result "slovo" 0)) 115) + (if (= (unwrap_ok (byte_at_result "slovo" 3)) 118) + (if (= (unwrap_err (byte_at_result "slovo" -1)) 1) + (= (unwrap_err (byte_at_result "slovo" 5)) 1) + false) + false) + false)) + +(fn imported_string_slice_ok () -> bool + (if (= (unwrap_ok (slice_result "slovo" 1 3)) "lov") + (if (= (unwrap_ok (slice_result "slovo" 0 5)) "slovo") + (= (unwrap_err (slice_result "slovo" 4 2)) 1) + false) + false)) + +(fn imported_string_boundaries_ok () -> bool + (if (starts_with "slovo" "slo") + (if (starts_with "slovo" "") + (if (starts_with "slovo" "ovo") + false + (if (ends_with "slovo" "ovo") + (if (ends_with "slovo" "") + (if (ends_with "slovo" "slo") + false + true) + false) + false)) + false) + false)) + (fn imported_string_parse_result_ok () -> bool (if (= (unwrap_ok (parse_i32_result "40")) 40) (if (= (unwrap_ok (parse_u32_result "40")) 40u32) @@ -158,11 +189,17 @@ (fn imported_string_helpers_ok () -> bool (if (= (imported_string_len_concat_score) 42) - (if (imported_string_parse_result_ok) - (if (imported_string_parse_options_ok) - (if (imported_string_parse_integer_fallbacks_ok) - (if (imported_string_parse_float_bool_fallbacks_ok) - (imported_string_parse_custom_fallbacks_ok) + (if (imported_string_byte_at_ok) + (if (imported_string_slice_ok) + (if (imported_string_boundaries_ok) + (if (imported_string_parse_result_ok) + (if (imported_string_parse_options_ok) + (if (imported_string_parse_integer_fallbacks_ok) + (if (imported_string_parse_float_bool_fallbacks_ok) + (imported_string_parse_custom_fallbacks_ok) + false) + false) + false) false) false) false) @@ -177,6 +214,15 @@ (test "explicit std string len concat" (= (imported_string_len_concat_score) 42)) +(test "explicit std string byte_at_result wrapper" + (imported_string_byte_at_ok)) + +(test "explicit std string slice_result wrapper" + (imported_string_slice_ok)) + +(test "explicit std string boundary wrappers" + (imported_string_boundaries_ok)) + (test "explicit std string parse result wrappers" (imported_string_parse_result_ok)) diff --git a/examples/projects/std-import-string/src/main.slo b/examples/projects/std-import-string/src/main.slo index 5ae4c9f..74b36c2 100644 --- a/examples/projects/std-import-string/src/main.slo +++ b/examples/projects/std-import-string/src/main.slo @@ -1,6 +1,6 @@ (module main) -(import std.string (len concat parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) +(import std.string (len concat byte_at_result slice_result starts_with ends_with parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) (fn imported_string_concat () -> string (concat "slo" "vo")) @@ -8,6 +8,37 @@ (fn imported_string_len_concat_score () -> i32 (+ (len (imported_string_concat)) 37)) +(fn imported_string_byte_at_ok () -> bool + (if (= (unwrap_ok (byte_at_result "slovo" 0)) 115) + (if (= (unwrap_ok (byte_at_result "slovo" 3)) 118) + (if (= (unwrap_err (byte_at_result "slovo" -1)) 1) + (= (unwrap_err (byte_at_result "slovo" 5)) 1) + false) + false) + false)) + +(fn imported_string_slice_ok () -> bool + (if (= (unwrap_ok (slice_result "slovo" 1 3)) "lov") + (if (= (unwrap_ok (slice_result "slovo" 0 5)) "slovo") + (= (unwrap_err (slice_result "slovo" 4 2)) 1) + false) + false)) + +(fn imported_string_boundaries_ok () -> bool + (if (starts_with "slovo" "slo") + (if (starts_with "slovo" "") + (if (starts_with "slovo" "ovo") + false + (if (ends_with "slovo" "ovo") + (if (ends_with "slovo" "") + (if (ends_with "slovo" "slo") + false + true) + false) + false)) + false) + false)) + (fn imported_string_parse_result_ok () -> bool (if (= (unwrap_ok (parse_i32_result "40")) 40) (if (= (unwrap_ok (parse_u32_result "40")) 40u32) @@ -158,11 +189,17 @@ (fn imported_string_helpers_ok () -> bool (if (= (imported_string_len_concat_score) 42) - (if (imported_string_parse_result_ok) - (if (imported_string_parse_options_ok) - (if (imported_string_parse_integer_fallbacks_ok) - (if (imported_string_parse_float_bool_fallbacks_ok) - (imported_string_parse_custom_fallbacks_ok) + (if (imported_string_byte_at_ok) + (if (imported_string_slice_ok) + (if (imported_string_boundaries_ok) + (if (imported_string_parse_result_ok) + (if (imported_string_parse_options_ok) + (if (imported_string_parse_integer_fallbacks_ok) + (if (imported_string_parse_float_bool_fallbacks_ok) + (imported_string_parse_custom_fallbacks_ok) + false) + false) + false) false) false) false) @@ -177,6 +214,15 @@ (test "explicit std string len concat" (= (imported_string_len_concat_score) 42)) +(test "explicit std string byte_at_result wrapper" + (imported_string_byte_at_ok)) + +(test "explicit std string slice_result wrapper" + (imported_string_slice_ok)) + +(test "explicit std string boundary wrappers" + (imported_string_boundaries_ok)) + (test "explicit std string parse result wrappers" (imported_string_parse_result_ok)) diff --git a/examples/projects/std-layout-local-string/src/main.slo b/examples/projects/std-layout-local-string/src/main.slo index a4bdf77..34c2f97 100644 --- a/examples/projects/std-layout-local-string/src/main.slo +++ b/examples/projects/std-layout-local-string/src/main.slo @@ -1,6 +1,6 @@ (module main) -(import string (len concat parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) +(import string (len concat byte_at_result slice_result starts_with ends_with parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) (fn imported_string_concat () -> string (concat "slo" "vo")) @@ -8,6 +8,37 @@ (fn imported_string_len_concat_score () -> i32 (+ (len (imported_string_concat)) 37)) +(fn imported_string_byte_at_ok () -> bool + (if (= (unwrap_ok (byte_at_result "slovo" 0)) 115) + (if (= (unwrap_ok (byte_at_result "slovo" 3)) 118) + (if (= (unwrap_err (byte_at_result "slovo" -1)) 1) + (= (unwrap_err (byte_at_result "slovo" 5)) 1) + false) + false) + false)) + +(fn imported_string_slice_ok () -> bool + (if (= (unwrap_ok (slice_result "slovo" 1 3)) "lov") + (if (= (unwrap_ok (slice_result "slovo" 0 5)) "slovo") + (= (unwrap_err (slice_result "slovo" 4 2)) 1) + false) + false)) + +(fn imported_string_boundaries_ok () -> bool + (if (starts_with "slovo" "slo") + (if (starts_with "slovo" "") + (if (starts_with "slovo" "ovo") + false + (if (ends_with "slovo" "ovo") + (if (ends_with "slovo" "") + (if (ends_with "slovo" "slo") + false + true) + false) + false)) + false) + false)) + (fn imported_string_parse_result_ok () -> bool (if (= (unwrap_ok (parse_i32_result "40")) 40) (if (= (unwrap_ok (parse_u32_result "40")) 40u32) @@ -158,11 +189,17 @@ (fn imported_string_helpers_ok () -> bool (if (= (imported_string_len_concat_score) 42) - (if (imported_string_parse_result_ok) - (if (imported_string_parse_options_ok) - (if (imported_string_parse_integer_fallbacks_ok) - (if (imported_string_parse_float_bool_fallbacks_ok) - (imported_string_parse_custom_fallbacks_ok) + (if (imported_string_byte_at_ok) + (if (imported_string_slice_ok) + (if (imported_string_boundaries_ok) + (if (imported_string_parse_result_ok) + (if (imported_string_parse_options_ok) + (if (imported_string_parse_integer_fallbacks_ok) + (if (imported_string_parse_float_bool_fallbacks_ok) + (imported_string_parse_custom_fallbacks_ok) + false) + false) + false) false) false) false) @@ -177,6 +214,15 @@ (test "explicit local string len concat" (= (imported_string_len_concat_score) 42)) +(test "explicit local string byte_at_result wrapper" + (imported_string_byte_at_ok)) + +(test "explicit local string slice_result wrapper" + (imported_string_slice_ok)) + +(test "explicit local string boundary wrappers" + (imported_string_boundaries_ok)) + (test "explicit local string parse result wrappers" (imported_string_parse_result_ok)) diff --git a/examples/projects/std-layout-local-string/src/string.slo b/examples/projects/std-layout-local-string/src/string.slo index 6191345..d324979 100644 --- a/examples/projects/std-layout-local-string/src/string.slo +++ b/examples/projects/std-layout-local-string/src/string.slo @@ -1,4 +1,4 @@ -(module string (export len concat parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) +(module string (export len concat byte_at_result slice_result starts_with ends_with parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) (import result (ok_or_none_i32 ok_or_none_u32 ok_or_none_i64 ok_or_none_u64 ok_or_none_f64 ok_or_none_bool)) @@ -8,6 +8,18 @@ (fn concat ((left string) (right string)) -> string (std.string.concat left right)) +(fn byte_at_result ((value string) (index i32)) -> (result i32 i32) + (std.string.byte_at_result value index)) + +(fn slice_result ((value string) (start i32) (count i32)) -> (result string i32) + (std.string.slice_result value start count)) + +(fn starts_with ((value string) (prefix string)) -> bool + (std.string.starts_with value prefix)) + +(fn ends_with ((value string) (suffix string)) -> bool + (std.string.ends_with value suffix)) + (fn parse_i32_result ((value string)) -> (result i32 i32) (std.string.parse_i32_result value)) diff --git a/lib/std/README.md b/lib/std/README.md index 3bae2d6..c3b9583 100644 --- a/lib/std/README.md +++ b/lib/std/README.md @@ -21,7 +21,8 @@ facade source search promoted in `exp-53`; io value helpers updated through helpers updated through `exp-54`, `exp-55`, and `exp-72`; CLI option helpers updated through `exp-110`; CLI local-source gate aligned in `exp-78`; string fallback helpers updated through `exp-60` and -`exp-68`; string option helpers updated through `exp-110`; process fallback +`exp-68`; string option helpers updated through `exp-110`; string +byte-scanning and token-boundary helpers updated in `1.0.0-beta.16`; process fallback helpers updated through `exp-61`; process typed helpers updated through `exp-67` and `exp-71`; process option helpers updated through `exp-110`; env fallback helpers updated through `exp-62` and `exp-69`; env typed helpers @@ -154,7 +155,7 @@ standard-runtime calls cataloged in `../STANDARD_RUNTIME.md`. The current `.slo` files use flat module declarations such as `(module math)`. 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, exp-108, -and `1.0.0-beta.12`, `std/math.slo`, `std/result.slo`, +`1.0.0-beta.12`, and `1.0.0-beta.16`, `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/json.slo`, `std/string.slo`, `std/num.slo`, `std/io.slo`, `std/process.slo`, `std/cli.slo`, `std/vec_i32.slo`, @@ -215,6 +216,12 @@ the exp-109 `std.result.ok_or_none_*` bridge helpers. The current Slovo-side exp-125 target adds matching `parse_u32_result`, `parse_u32_option`, `parse_u32_or_zero`, `parse_u32_or`, `parse_u64_result`, `parse_u64_option`, `parse_u64_or_zero`, and `parse_u64_or` lanes. +`1.0.0-beta.16` adds `byte_at_result`, `slice_result`, `starts_with`, and +`ends_with` as byte-oriented helpers over current runtime strings. Invalid +byte indexes and ranges return `err 1`; empty prefixes and suffixes match. +This string scanning foundation does not add Unicode scalar or grapheme +semantics, JSON parsing, tokenizer objects, language-level slice/view syntax, +mutable strings, stable ABI/layout promises, or a stable stdlib/API freeze. `std/num.slo` includes the exp-31 `f64_to_i64_result` wrapper over `std.num.f64_to_i64_result`. exp-64 adds `i64_to_i32_or`, `f64_to_i32_or`, and `f64_to_i64_or` as ordinary source `match` helpers over the existing diff --git a/lib/std/string.slo b/lib/std/string.slo index f5245f2..01ce700 100644 --- a/lib/std/string.slo +++ b/lib/std/string.slo @@ -1,4 +1,4 @@ -(module string (export len concat parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) +(module string (export len concat byte_at_result slice_result starts_with ends_with parse_i32_result parse_i32_option parse_u32_result parse_u32_option parse_i64_result parse_i64_option parse_u64_result parse_u64_option parse_f64_result parse_f64_option parse_bool_result parse_bool_option parse_i32_or_zero parse_u32_or_zero parse_i64_or_zero parse_u64_or_zero parse_f64_or_zero parse_bool_or_false parse_i32_or parse_u32_or parse_i64_or parse_u64_or parse_f64_or parse_bool_or)) (import std.result (ok_or_none_i32 ok_or_none_u32 ok_or_none_i64 ok_or_none_u64 ok_or_none_f64 ok_or_none_bool)) @@ -8,6 +8,18 @@ (fn concat ((left string) (right string)) -> string (std.string.concat left right)) +(fn byte_at_result ((value string) (index i32)) -> (result i32 i32) + (std.string.byte_at_result value index)) + +(fn slice_result ((value string) (start i32) (count i32)) -> (result string i32) + (std.string.slice_result value start count)) + +(fn starts_with ((value string) (prefix string)) -> bool + (std.string.starts_with value prefix)) + +(fn ends_with ((value string) (suffix string)) -> bool + (std.string.ends_with value suffix)) + (fn parse_i32_result ((value string)) -> (result i32 i32) (std.string.parse_i32_result value)) diff --git a/runtime/runtime.c b/runtime/runtime.c index 6591f5f..00aa23a 100644 --- a/runtime/runtime.c +++ b/runtime/runtime.c @@ -726,6 +726,65 @@ char *__glagol_string_concat(const char *left, const char *right) { return value; } +int64_t __glagol_string_byte_at_result(const char *value, int32_t index) { + if (value == NULL || index < 0) { + return __glagol_result_i32_err(); + } + + size_t length = strlen(value); + size_t offset = (size_t)index; + if (offset >= length) { + return __glagol_result_i32_err(); + } + + return __glagol_result_i32_encode(0, (int32_t)(unsigned char)value[offset]); +} + +char *__glagol_string_slice_result(const char *value, int32_t start, int32_t count) { + if (value == NULL || start < 0 || count < 0) { + return NULL; + } + + size_t length = strlen(value); + size_t offset = (size_t)start; + size_t slice_len = (size_t)count; + if (offset > length || slice_len > length - offset) { + return NULL; + } + + char *slice = malloc(slice_len + 1u); + if (slice == NULL) { + __glagol_allocation_trap(); + } + + if (slice_len > 0) { + memcpy(slice, value + offset, slice_len); + } + slice[slice_len] = '\0'; + return slice; +} + +bool __glagol_string_starts_with(const char *value, const char *prefix) { + if (value == NULL || prefix == NULL) { + return false; + } + + size_t value_len = strlen(value); + size_t prefix_len = strlen(prefix); + return prefix_len <= value_len && memcmp(value, prefix, prefix_len) == 0; +} + +bool __glagol_string_ends_with(const char *value, const char *suffix) { + if (value == NULL || suffix == NULL) { + return false; + } + + size_t value_len = strlen(value); + size_t suffix_len = strlen(suffix); + return suffix_len <= value_len + && memcmp(value + value_len - suffix_len, suffix, suffix_len) == 0; +} + static char __glagol_json_hex_digit(unsigned char value) { return value < 10u ? (char)('0' + value) : (char)('A' + (value - 10u)); } diff --git a/scripts/release-gate.sh b/scripts/release-gate.sh index d38ad71..0d58f89 100755 --- a/scripts/release-gate.sh +++ b/scripts/release-gate.sh @@ -66,6 +66,7 @@ cargo fmt --check cargo test --test diagnostics_schema_beta13 cargo test --test benchmark_suite_catalog_beta14 cargo test --test reserved_generic_collection_beta15 +cargo test --test standard_string_scanning_beta16 # Full cargo test includes unignored integration gates such as dx_v1_7, # beta_v2_0_0_beta_1, and beta_1_0_0. cargo test diff --git a/tests/std-abi-layout-unsupported.diag b/tests/std-abi-layout-unsupported.diag index d21f4c3..a726e30 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 edecb74..3053c0d 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 5c3437d..8eb0225 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 bfde428..0478d8a 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 8ab9a3b..e101bf5 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 8317d92..43193da 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 1101901..63f4857 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 7ef4893..5100465 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 11397ea..4f49b44 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 9a5bf6a..1ecc0d6 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 987a8ca..1ced282 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 ee5ddeb..d071118 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 7d683c9..4d1cddf 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 9a8fb1c..e92805d 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 19bf6da..341201b 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 92031ca..2ca40e9 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 e267d38..9f075ae 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 14ec6ce..ad56bdf 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 c87c66b..659d938 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 083566d..3ce123f 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 97dcec6..7b944cf 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 49e1b84..ce8a830 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 ffa894f..3f87a08 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 2e1c052..cbe5065 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 8dc9e22..5f44dd4 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 c733d94..82a342c 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 f03cf2a..db7a325 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 aa2f5a7..e4b9305 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 3198efb..7c96627 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 b112a3b..d5784dc 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 daac9d3..8610ce2 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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-string-byte-at-result-arity.diag b/tests/std-string-byte-at-result-arity.diag new file mode 100644 index 0000000..dccb8a8 --- /dev/null +++ b/tests/std-string-byte-at-result-arity.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code ArityMismatch) + (message "function `std.string.byte_at_result` called with wrong number of arguments") + (file "") + (span + (bytes 50 83) + (range 5 3 5 36) + ) + (expected "2") + (found "1") +) diff --git a/tests/std-string-byte-at-result-bool-context.diag b/tests/std-string-byte-at-result-bool-context.diag new file mode 100644 index 0000000..efa70b9 --- /dev/null +++ b/tests/std-string-byte-at-result-bool-context.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code IfConditionNotBool) + (message "`if` condition must be bool") + (file "") + (span + (bytes 41 76) + (range 5 7 5 42) + ) + (expected "bool") + (found "(result i32 i32)") +) diff --git a/tests/std-string-byte-at-result-context.diag b/tests/std-string-byte-at-result-context.diag new file mode 100644 index 0000000..c7b7fc8 --- /dev/null +++ b/tests/std-string-byte-at-result-context.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code ReturnTypeMismatch) + (message "function `main` returns wrong type") + (file "") + (span + (bytes 16 73) + (range 4 1 5 39) + ) + (expected "i32") + (found "(result i32 i32)") +) diff --git a/tests/std-string-byte-at-result-helper-shadow.diag b/tests/std-string-byte-at-result-helper-shadow.diag new file mode 100644 index 0000000..9e8d2cb --- /dev/null +++ b/tests/std-string-byte-at-result-helper-shadow.diag @@ -0,0 +1,12 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code DuplicateFunction) + (message "compiler-known callable `__glagol_string_byte_at_result` is reserved") + (file "") + (span + (bytes 16 117) + (range 4 1 5 19) + ) +) diff --git a/tests/std-string-byte-at-result-name-shadow.diag b/tests/std-string-byte-at-result-name-shadow.diag new file mode 100644 index 0000000..7271739 --- /dev/null +++ b/tests/std-string-byte-at-result-name-shadow.diag @@ -0,0 +1,12 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code DuplicateFunction) + (message "duplicate function `std.string.byte_at_result`") + (file "") + (span + (bytes 16 112) + (range 4 1 5 19) + ) +) diff --git a/tests/std-string-byte-at-result-type.diag b/tests/std-string-byte-at-result-type.diag new file mode 100644 index 0000000..98890e8 --- /dev/null +++ b/tests/std-string-byte-at-result-type.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code TypeMismatch) + (message "cannot call `std.string.byte_at_result` with argument of wrong type") + (file "") + (span + (bytes 83 86) + (range 5 36 5 39) + ) + (expected "i32") + (found "string") +) diff --git a/tests/std-string-byte-at-unsupported.diag b/tests/std-string-byte-at-unsupported.diag new file mode 100644 index 0000000..09598b5 --- /dev/null +++ b/tests/std-string-byte-at-unsupported.diag @@ -0,0 +1,15 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code UnsupportedStandardLibraryCall) + (message "standard library call `std.string.byte_at` is not supported") + (file "") + (span + (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.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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.byte_at") + (hint "use a promoted standard-runtime name or a legacy intrinsic alias") +) diff --git a/tests/std-string-contains-unsupported.diag b/tests/std-string-contains-unsupported.diag new file mode 100644 index 0000000..28be4f4 --- /dev/null +++ b/tests/std-string-contains-unsupported.diag @@ -0,0 +1,15 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code UnsupportedStandardLibraryCall) + (message "standard library call `std.string.contains` is not supported") + (file "") + (span + (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.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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.contains") + (hint "use a promoted standard-runtime name or a legacy intrinsic alias") +) diff --git a/tests/std-string-ends-with-arity.diag b/tests/std-string-ends-with-arity.diag new file mode 100644 index 0000000..e3e2ae2 --- /dev/null +++ b/tests/std-string-ends-with-arity.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code ArityMismatch) + (message "function `std.string.ends_with` called with wrong number of arguments") + (file "") + (span + (bytes 38 66) + (range 5 3 5 31) + ) + (expected "2") + (found "1") +) diff --git a/tests/std-string-ends-with-context.diag b/tests/std-string-ends-with-context.diag new file mode 100644 index 0000000..78ee2be --- /dev/null +++ b/tests/std-string-ends-with-context.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code ReturnTypeMismatch) + (message "function `main` returns wrong type") + (file "") + (span + (bytes 16 70) + (range 4 1 5 36) + ) + (expected "i32") + (found "bool") +) diff --git a/tests/std-string-ends-with-helper-shadow.diag b/tests/std-string-ends-with-helper-shadow.diag new file mode 100644 index 0000000..4ce3183 --- /dev/null +++ b/tests/std-string-ends-with-helper-shadow.diag @@ -0,0 +1,12 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code DuplicateFunction) + (message "compiler-known callable `__glagol_string_ends_with` is reserved") + (file "") + (span + (bytes 16 94) + (range 4 1 5 9) + ) +) diff --git a/tests/std-string-ends-with-name-shadow.diag b/tests/std-string-ends-with-name-shadow.diag new file mode 100644 index 0000000..7b0445d --- /dev/null +++ b/tests/std-string-ends-with-name-shadow.diag @@ -0,0 +1,12 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code DuplicateFunction) + (message "duplicate function `std.string.ends_with`") + (file "") + (span + (bytes 16 89) + (range 4 1 5 9) + ) +) diff --git a/tests/std-string-ends-with-type.diag b/tests/std-string-ends-with-type.diag new file mode 100644 index 0000000..90e43be --- /dev/null +++ b/tests/std-string-ends-with-type.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code TypeMismatch) + (message "cannot call `std.string.ends_with` with argument of wrong type") + (file "") + (span + (bytes 66 67) + (range 5 31 5 32) + ) + (expected "string") + (found "i32") +) diff --git a/tests/std-string-find-result-unsupported.diag b/tests/std-string-find-result-unsupported.diag new file mode 100644 index 0000000..4f6753b --- /dev/null +++ b/tests/std-string-find-result-unsupported.diag @@ -0,0 +1,15 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code UnsupportedStandardLibraryCall) + (message "standard library call `std.string.find_result` is not supported") + (file "") + (span + (bytes 38 60) + (range 5 4 5 26) + ) + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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.find_result") + (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 d74c685..38ec7e4 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 6e20707..c8be3b2 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 cc516c9..6bdf304 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 858017f..4600ea8 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 5fec889..931c16f 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 5cf6f75..621100f 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 303404a..7593440 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 27fc05e..f3b9e21 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 730d332..6ae4741 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 3155856..bb29e0a 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 77366da..287a22c 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 5f3ec2c..da88988 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 52a8130..39df130 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 1f48679..7f62c96 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 c824755..1593f8a 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 92babef..9daff44 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 db580e4..a7d2d26 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 684113e..8e11068 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 3e160a4..38e3555 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 73a8d2e..f21aba9 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 bc6b616..3ad491f 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 18b59fa..1d6de54 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 49367c5..be7fb87 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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-result-arity.diag b/tests/std-string-slice-result-arity.diag new file mode 100644 index 0000000..b2552a9 --- /dev/null +++ b/tests/std-string-slice-result-arity.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code ArityMismatch) + (message "function `std.string.slice_result` called with wrong number of arguments") + (file "") + (span + (bytes 53 86) + (range 5 3 5 36) + ) + (expected "3") + (found "2") +) diff --git a/tests/std-string-slice-result-bool-context.diag b/tests/std-string-slice-result-bool-context.diag new file mode 100644 index 0000000..be280b3 --- /dev/null +++ b/tests/std-string-slice-result-bool-context.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code IfConditionNotBool) + (message "`if` condition must be bool") + (file "") + (span + (bytes 41 76) + (range 5 7 5 42) + ) + (expected "bool") + (found "(result string i32)") +) diff --git a/tests/std-string-slice-result-context.diag b/tests/std-string-slice-result-context.diag new file mode 100644 index 0000000..ba60220 --- /dev/null +++ b/tests/std-string-slice-result-context.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code ReturnTypeMismatch) + (message "function `main` returns wrong type") + (file "") + (span + (bytes 16 76) + (range 4 1 5 39) + ) + (expected "string") + (found "(result string i32)") +) diff --git a/tests/std-string-slice-result-helper-shadow.diag b/tests/std-string-slice-result-helper-shadow.diag new file mode 100644 index 0000000..2580cb6 --- /dev/null +++ b/tests/std-string-slice-result-helper-shadow.diag @@ -0,0 +1,12 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code DuplicateFunction) + (message "compiler-known callable `__glagol_string_slice_result` is reserved") + (file "") + (span + (bytes 16 133) + (range 4 1 5 22) + ) +) diff --git a/tests/std-string-slice-result-name-shadow.diag b/tests/std-string-slice-result-name-shadow.diag new file mode 100644 index 0000000..d3d74d9 --- /dev/null +++ b/tests/std-string-slice-result-name-shadow.diag @@ -0,0 +1,12 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code DuplicateFunction) + (message "duplicate function `std.string.slice_result`") + (file "") + (span + (bytes 16 128) + (range 4 1 5 22) + ) +) diff --git a/tests/std-string-slice-result-type.diag b/tests/std-string-slice-result-type.diag new file mode 100644 index 0000000..90f3326 --- /dev/null +++ b/tests/std-string-slice-result-type.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code TypeMismatch) + (message "cannot call `std.string.slice_result` with argument of wrong type") + (file "") + (span + (bytes 86 89) + (range 5 36 5 39) + ) + (expected "i32") + (found "string") +) diff --git a/tests/std-string-slice-unsupported.diag b/tests/std-string-slice-unsupported.diag index 580b8b2..6edb650 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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-split-unsupported.diag b/tests/std-string-split-unsupported.diag new file mode 100644 index 0000000..ce61db8 --- /dev/null +++ b/tests/std-string-split-unsupported.diag @@ -0,0 +1,15 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code UnsupportedStandardLibraryCall) + (message "standard library call `std.string.split` is not supported") + (file "") + (span + (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.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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.split") + (hint "use a promoted standard-runtime name or a legacy intrinsic alias") +) diff --git a/tests/std-string-starts-with-arity.diag b/tests/std-string-starts-with-arity.diag new file mode 100644 index 0000000..c19783f --- /dev/null +++ b/tests/std-string-starts-with-arity.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code ArityMismatch) + (message "function `std.string.starts_with` called with wrong number of arguments") + (file "") + (span + (bytes 38 68) + (range 5 3 5 33) + ) + (expected "2") + (found "1") +) diff --git a/tests/std-string-starts-with-context.diag b/tests/std-string-starts-with-context.diag new file mode 100644 index 0000000..8d0e225 --- /dev/null +++ b/tests/std-string-starts-with-context.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code ReturnTypeMismatch) + (message "function `main` returns wrong type") + (file "") + (span + (bytes 16 72) + (range 4 1 5 38) + ) + (expected "i32") + (found "bool") +) diff --git a/tests/std-string-starts-with-helper-shadow.diag b/tests/std-string-starts-with-helper-shadow.diag new file mode 100644 index 0000000..cbc5e8b --- /dev/null +++ b/tests/std-string-starts-with-helper-shadow.diag @@ -0,0 +1,12 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code DuplicateFunction) + (message "compiler-known callable `__glagol_string_starts_with` is reserved") + (file "") + (span + (bytes 16 96) + (range 4 1 5 9) + ) +) diff --git a/tests/std-string-starts-with-name-shadow.diag b/tests/std-string-starts-with-name-shadow.diag new file mode 100644 index 0000000..6162c99 --- /dev/null +++ b/tests/std-string-starts-with-name-shadow.diag @@ -0,0 +1,12 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code DuplicateFunction) + (message "duplicate function `std.string.starts_with`") + (file "") + (span + (bytes 16 91) + (range 4 1 5 9) + ) +) diff --git a/tests/std-string-starts-with-type.diag b/tests/std-string-starts-with-type.diag new file mode 100644 index 0000000..43b4b6f --- /dev/null +++ b/tests/std-string-starts-with-type.diag @@ -0,0 +1,14 @@ +(diagnostic + (schema slovo.diagnostic) + (version 1) + (severity error) + (code TypeMismatch) + (message "cannot call `std.string.starts_with` with argument of wrong type") + (file "") + (span + (bytes 68 69) + (range 5 33 5 34) + ) + (expected "string") + (found "i32") +) diff --git a/tests/std-string-tokenize-unsupported.diag b/tests/std-string-tokenize-unsupported.diag index 759bf81..7c0fd89 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 767efab..0b398b1 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 00bbf13..ec07127 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 ec9ea9b..b295855 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 057467c..ecb7508 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 6c7acc7..b339991 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 f5a3fd6..bd24ea9 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 901e8de..0659959 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 f2ff3d9..c92e31b 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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 bd24de3..b817557 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.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") + (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.byte_at_result, std.string.slice_result, std.string.starts_with, std.string.ends_with, std.string.parse_i32_result, std.string.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") )