Hermeticum/slovo
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Release 1.0.0-beta.16 string scanning foundation

Browse Source
This commit is contained in:
sanjin 2026-05-22 23:00:07 +02:00
parent 436261730a
commit ddb8afd904
120 changed files with 2105 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
.llm/BETA_16_STRING_SCANNING_AND_TOKEN_BOUNDARY_FOUNDATION.md Normal file
View File

@ -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

55
.llm/reviews/BETA_16_RELEASE_REVIEW.md Normal file
View File

@ -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.

51
README.md
View File

@ -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

2
compiler/Cargo.lock generated
View File

@ -4,4 +4,4 @@ version = 3
[[package]]
name = "glagol"
version = "1.0.0-beta.15"
version = "1.0.0-beta.16"

2
compiler/Cargo.toml
View File

@ -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"

6
compiler/src/llvm.rs
View File

@ -26,6 +26,10 @@ pub fn emit(_file: &str, program: &CheckedProgram) -> Result<String, Vec<Diagnos
out.push_str("declare void @print_bool(i1)\n\n");
out.push_str("declare i32 @string_len(ptr)\n\n");
out.push_str("declare ptr @__glagol_string_concat(ptr, ptr)\n\n");
out.push_str("declare i64 @__glagol_string_byte_at_result(ptr, i32)\n\n");
out.push_str("declare ptr @__glagol_string_slice_result(ptr, i32, i32)\n\n");
out.push_str("declare i1 @__glagol_string_starts_with(ptr, ptr)\n\n");
out.push_str("declare i1 @__glagol_string_ends_with(ptr, ptr)\n\n");
out.push_str("declare i64 @__glagol_string_parse_i32_result(ptr)\n\n");
out.push_str("declare i32 @__glagol_string_parse_i64_result(ptr, ptr)\n\n");
out.push_str("declare i64 @__glagol_string_parse_u32_result(ptr)\n\n");
@ -1671,6 +1675,7 @@ impl FunctionGen<'_> {
| "__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);
}

37
compiler/src/std_runtime.rs
View File

@ -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")
}

270
compiler/src/test_runner.rs
View File

@ -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<String, Value>,
functions: &HashMap<&str, &CheckedFunction>,
foreign_imports: &HashSet<&str>,
depth: usize,
) -> Result<Value, Diagnostic> {
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<String, Value>,
functions: &HashMap<&str, &CheckedFunction>,
foreign_imports: &HashSet<&str>,
depth: usize,
) -> Result<Value, Diagnostic> {
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<String, Value>,
functions: &HashMap<&str, &CheckedFunction>,
foreign_imports: &HashSet<&str>,
depth: usize,
) -> Result<Value, Diagnostic> {
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<String, Value>,
functions: &HashMap<&str, &CheckedFunction>,
foreign_imports: &HashSet<&str>,
depth: usize,
) -> Result<Value, Diagnostic> {
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(

287
compiler/tests/diagnostics_contract.rs
View File

@ -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#"

48
compiler/tests/promotion_gate.rs
View File

@ -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",
],

9
compiler/tests/standard_core_facade_source_search_alpha.rs
View File

@ -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",

309
compiler/tests/standard_string_scanning_beta16.rs Normal file
View File

@ -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<I, S>(args: I) -> Output
where
I: IntoIterator<Item = S>,
S: AsRef<OsStr>,
{
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<PathBuf> {
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<PathBuf> {
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);
}

13
compiler/tests/standard_string_source_fallback_helpers_alpha.rs
View File

@ -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",
] {

37
docs/POST_BETA_ROADMAP.md
View File

@ -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:

39
docs/compiler/RELEASE_NOTES.md
View File

@ -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`

17
docs/compiler/ROADMAP.md
View File

@ -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.

37
docs/language/RELEASE_NOTES.md
View File

@ -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`

94
docs/language/ROADMAP.md
View File

@ -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 <file|project|workspace> -o <dir>` 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

111
docs/language/SPEC-v1.md
View File

@ -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

24
docs/language/STANDARD_RUNTIME.md
View File

@ -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,

10
docs/language/STDLIB_API.md
View File

@ -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)`

48
docs/language/examples/projects/std-import-string/src/main.slo
View File

@ -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,6 +189,9 @@
(fn imported_string_helpers_ok () -> bool
(if (= (imported_string_len_concat_score) 42)
(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)
@ -167,6 +201,9 @@
false)
false)
false)
false)
false)
false)
false))
(fn main () -> i32
@ -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))

48
examples/projects/std-import-string/src/main.slo
View File

@ -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,6 +189,9 @@
(fn imported_string_helpers_ok () -> bool
(if (= (imported_string_len_concat_score) 42)
(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)
@ -167,6 +201,9 @@
false)
false)
false)
false)
false)
false)
false))
(fn main () -> i32
@ -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))

48
examples/projects/std-layout-local-string/src/main.slo
View File

@ -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,6 +189,9 @@
(fn imported_string_helpers_ok () -> bool
(if (= (imported_string_len_concat_score) 42)
(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)
@ -167,6 +201,9 @@
false)
false)
false)
false)
false)
false)
false))
(fn main () -> i32
@ -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))

14
examples/projects/std-layout-local-string/src/string.slo
View File

@ -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))

11
lib/std/README.md
View File

@ -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

14
lib/std/string.slo
View File

@ -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))

59
runtime/runtime.c
View File

@ -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));
}

1
scripts/release-gate.sh
View File

@ -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

2
tests/std-abi-layout-unsupported.diag
View File

@ -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")
)

2
tests/std-async-spawn-unsupported.diag
View File

@ -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")
)

2
tests/std-fs-list-dir-unsupported.diag
View File

@ -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")
)

2
tests/std-fs-read-binary-unsupported-alias.diag
View File

@ -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")
)

2
tests/std-io-prompt-unsupported.diag
View File

@ -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")
)

2
tests/std-io-read-line-unsupported.diag
View File

@ -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")
)

2
tests/std-io-read-stdin-async-unsupported.diag
View File

@ -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")
)

2
tests/std-io-read-stdin-binary-unsupported.diag
View File

@ -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")
)

2
tests/std-io-read-stdin-bytes-unsupported.diag
View File

@ -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")
)

2
tests/std-io-read-stdin-unsupported.diag
View File

@ -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")
)

2
tests/std-io-stdin-encoding-unsupported.diag
View File

@ -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")
)

2
tests/std-io-stdin-lines-unsupported.diag
View File

@ -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")
)

2
tests/std-io-stdin-stream-unsupported.diag
View File

@ -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")
)

2
tests/std-net-connect-unsupported.diag
View File

@ -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")
)

2
tests/std-num-cast-checked-unsupported.diag
View File

@ -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")
)

2
tests/std-num-cast-unsupported.diag
View File

@ -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")
)

2
tests/std-num-f64-to-i32-unsupported.diag
View File

@ -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")
)

2
tests/std-num-f64-to-i64-unsupported.diag
View File

@ -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")
)

2
tests/std-num-i32-to-i64-result-unsupported.diag
View File

@ -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")
)

2
tests/std-num-i64-to-i32-unsupported.diag
View File

@ -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")
)

2
tests/std-num-to-string-unsupported.diag
View File

@ -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")
)

2
tests/std-package-load-unsupported.diag
View File

@ -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")
)

2
tests/std-platform-os-unsupported.diag
View File

@ -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")
)

2
tests/std-random-bytes-unsupported.diag
View File

@ -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")
)

2
tests/std-random-crypto-i32-unsupported.diag
View File

@ -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")
)

2
tests/std-random-float-unsupported.diag
View File

@ -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")
)

2
tests/std-random-range-unsupported.diag
View File

@ -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")
)

2
tests/std-random-seed-unsupported.diag
View File

@ -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")
)

2
tests/std-random-shuffle-unsupported.diag
View File

@ -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")
)

2
tests/std-random-string-unsupported.diag
View File

@ -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")
)

2
tests/std-random-uuid-unsupported.diag
View File

@ -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")
)

14
tests/std-string-byte-at-result-arity.diag Normal file
View File

@ -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 "<fixture>")
(span
(bytes 50 83)
(range 5 3 5 36)
)
(expected "2")
(found "1")
)

14
tests/std-string-byte-at-result-bool-context.diag Normal file
View File

@ -0,0 +1,14 @@
(diagnostic
(schema slovo.diagnostic)
(version 1)
(severity error)
(code IfConditionNotBool)
(message "`if` condition must be bool")
(file "<fixture>")
(span
(bytes 41 76)
(range 5 7 5 42)
)
(expected "bool")
(found "(result i32 i32)")
)

14
tests/std-string-byte-at-result-context.diag Normal file
View File

@ -0,0 +1,14 @@
(diagnostic
(schema slovo.diagnostic)
(version 1)
(severity error)
(code ReturnTypeMismatch)
(message "function `main` returns wrong type")
(file "<fixture>")
(span
(bytes 16 73)
(range 4 1 5 39)
)
(expected "i32")
(found "(result i32 i32)")
)

12
tests/std-string-byte-at-result-helper-shadow.diag Normal file
View File

@ -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 "<fixture>")
(span
(bytes 16 117)
(range 4 1 5 19)
)
)

12
tests/std-string-byte-at-result-name-shadow.diag Normal file
View File

@ -0,0 +1,12 @@
(diagnostic
(schema slovo.diagnostic)
(version 1)
(severity error)
(code DuplicateFunction)
(message "duplicate function `std.string.byte_at_result`")
(file "<fixture>")
(span
(bytes 16 112)
(range 4 1 5 19)
)
)

14
tests/std-string-byte-at-result-type.diag Normal file
View File

@ -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 "<fixture>")
(span
(bytes 83 86)
(range 5 36 5 39)
)
(expected "i32")
(found "string")
)

15
tests/std-string-byte-at-unsupported.diag Normal file
View File

@ -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 "<fixture>")
(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")
)

15
tests/std-string-contains-unsupported.diag Normal file
View File

@ -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 "<fixture>")
(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")
)

14
tests/std-string-ends-with-arity.diag Normal file
View File

@ -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 "<fixture>")
(span
(bytes 38 66)
(range 5 3 5 31)
)
(expected "2")
(found "1")
)

14
tests/std-string-ends-with-context.diag Normal file
View File

@ -0,0 +1,14 @@
(diagnostic
(schema slovo.diagnostic)
(version 1)
(severity error)
(code ReturnTypeMismatch)
(message "function `main` returns wrong type")
(file "<fixture>")
(span
(bytes 16 70)
(range 4 1 5 36)
)
(expected "i32")
(found "bool")
)

12
tests/std-string-ends-with-helper-shadow.diag Normal file
View File

@ -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 "<fixture>")
(span
(bytes 16 94)
(range 4 1 5 9)
)
)

12
tests/std-string-ends-with-name-shadow.diag Normal file
View File

@ -0,0 +1,12 @@
(diagnostic
(schema slovo.diagnostic)
(version 1)
(severity error)
(code DuplicateFunction)
(message "duplicate function `std.string.ends_with`")
(file "<fixture>")
(span
(bytes 16 89)
(range 4 1 5 9)
)
)

14
tests/std-string-ends-with-type.diag Normal file
View File

@ -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 "<fixture>")
(span
(bytes 66 67)
(range 5 31 5 32)
)
(expected "string")
(found "i32")
)

15
tests/std-string-find-result-unsupported.diag Normal file
View File

@ -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 "<fixture>")
(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")
)

2
tests/std-string-from-i64-unsupported.diag
View File

@ -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")
)

2
tests/std-string-index-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-bool-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-bytes-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-f64-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-generic-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-base-prefix-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-binary-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-code-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-error-adt-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-hex-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-locale-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-message-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-octal-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-plus-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-radix-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-trim-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-underscore-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-unicode-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-i32-whitespace-unsupported.diag
View File

@ -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")
)

2
tests/std-string-parse-string-unsupported.diag
View File

@ -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")
)

2
tests/std-string-scan-unsupported.diag
View File

@ -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")
)

14
tests/std-string-slice-result-arity.diag Normal file
View File

@ -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 "<fixture>")
(span
(bytes 53 86)
(range 5 3 5 36)
)
(expected "3")
(found "2")
)

14
tests/std-string-slice-result-bool-context.diag Normal file
View File

@ -0,0 +1,14 @@
(diagnostic
(schema slovo.diagnostic)
(version 1)
(severity error)
(code IfConditionNotBool)
(message "`if` condition must be bool")
(file "<fixture>")
(span
(bytes 41 76)
(range 5 7 5 42)
)
(expected "bool")
(found "(result string i32)")
)

14
tests/std-string-slice-result-context.diag Normal file
View File

@ -0,0 +1,14 @@
(diagnostic
(schema slovo.diagnostic)
(version 1)
(severity error)
(code ReturnTypeMismatch)
(message "function `main` returns wrong type")
(file "<fixture>")
(span
(bytes 16 76)
(range 4 1 5 39)
)
(expected "string")
(found "(result string i32)")
)

Some files were not shown because too many files have changed in this diff Show More