#[cfg(all(feature = "no_std", not(feature = "std")))]
use alloc::{format, string::String};
pub fn variable_not_found(name: &str) -> String {
format!("Variable `{name}` not found")
}
pub fn function_not_found(name: &str) -> String {
format!("Function `{name}` not found")
}
pub fn struct_has_no_field(type_name: &str, field: &str) -> String {
format!("Struct `{type_name}` has no field `{field}`")
}
pub fn variant_has_no_field(type_name: &str, variant: &str, field: &str) -> String {
format!("Variant `{type_name}::{variant}` has no field `{field}`")
}
pub fn struct_not_declared(type_name: &str) -> String {
format!("Struct `{type_name}` is not declared")
}
pub fn enum_not_declared(type_name: &str) -> String {
format!("Enum `{type_name}` is not declared")
}
pub fn enum_has_no_variant(type_name: &str, variant: &str) -> String {
format!("Enum `{type_name}` has no variant `{variant}`")
}
pub fn cant_read_field(field: &str, kind: &str) -> String {
format!("Can't read field `{field}` on {kind}")
}
pub fn cant_assign_field(field: &str, kind: &str) -> String {
format!("Can't assign to field `{field}` on {kind}")
}
pub fn cant_call_a(kind: &str) -> String {
format!("Can't call a {kind}")
}
pub fn cant_iterate_over(kind: &str) -> String {
format!("Can't iterate over {kind}")
}
pub fn no_such_method(kind: &str, method: &str) -> String {
format!("{kind} doesn't have a .{method}() method")
}
pub fn glob_shadow_warning(name: &str, path: &str) -> String {
format!("`{name}` from `{path}` shadowed by an existing binding — the first definition wins")
}
pub const CONSTANT_MUTATION_HINT: &str =
"constants are immutable. Use `let` if you want a mutable binding.";
pub fn constant_mutation_error(name: &str, line: u32) -> crate::error::NyblError {
let mut error = crate::error::NyblError::runtime(
format!("can't reassign `{name}` — it's a constant"),
line,
);
error.friendly_hint = Some(String::from(CONSTANT_MUTATION_HINT));
error
}
pub const NESTED_MUTATION_ERROR_MESSAGE: &str =
"can't mutate through an index or field receiver yet";
pub const NESTED_MUTATION_HINT: &str =
"Assign the value to a variable, mutate that variable, then assign it back.";
pub const TOP_LEVEL_TRY_ERROR_MESSAGE: &str = "try encountered Err at top-level";
pub const TOP_LEVEL_TRY_HINT: &str =
"Wrap the calling code in a fn, or use `match` to handle both arms explicitly.";
pub fn top_level_try_error(line: u32) -> crate::error::NyblError {
let mut error = crate::error::NyblError::runtime(TOP_LEVEL_TRY_ERROR_MESSAGE, line);
error.friendly_hint = Some(String::from(TOP_LEVEL_TRY_HINT));
error
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn variable_not_found_format() {
assert_eq!(variable_not_found("x"), "Variable `x` not found");
}
#[test]
fn struct_has_no_field_matches_legacy_format() {
assert_eq!(
struct_has_no_field("Point", "z"),
"Struct `Point` has no field `z`"
);
}
#[test]
fn variant_has_no_field_uses_double_colon() {
assert_eq!(
variant_has_no_field("Shape", "Rect", "r"),
"Variant `Shape::Rect` has no field `r`"
);
}
#[test]
fn cant_read_field_formats_without_backticks_around_kind() {
assert_eq!(
cant_read_field("x", "array"),
"Can't read field `x` on array"
);
}
#[test]
fn nested_array_mutation_explains_the_workaround() {
assert_eq!(
NESTED_MUTATION_ERROR_MESSAGE,
"can't mutate through an index or field receiver yet"
);
assert_eq!(
NESTED_MUTATION_HINT,
"Assign the value to a variable, mutate that variable, then assign it back."
);
}
#[test]
fn glob_shadow_warning_is_the_cross_engine_contract() {
assert_eq!(
glob_shadow_warning("alpha", "second"),
"`alpha` from `second` shadowed by an existing binding — the first definition wins"
);
}
#[test]
fn constant_mutation_error_keeps_message_hint_and_line_together() {
let error = constant_mutation_error("VALUES", 12);
assert_eq!(error.line, Some(12));
assert_eq!(error.message, "can't reassign `VALUES` — it's a constant");
assert_eq!(error.friendly_hint.as_deref(), Some(CONSTANT_MUTATION_HINT));
}
#[test]
fn top_level_try_error_keeps_message_hint_and_line_together() {
let error = top_level_try_error(17);
assert_eq!(error.line, Some(17));
assert_eq!(error.message, TOP_LEVEL_TRY_ERROR_MESSAGE);
assert_eq!(error.friendly_hint.as_deref(), Some(TOP_LEVEL_TRY_HINT));
}
}