use super::*;
#[test]
fn help_and_note_children_survive_the_remap() {
let message = serde_json::json!({
"level": "error",
"message": "mismatched types",
"children": [
{ "level": "help", "message": "consider borrowing here" },
{ "level": "note", "message": "expected `&str`, found `String`" },
{ "level": "error", "message": "not a child worth repeating" },
],
});
let notes = notes_of(&message);
assert_eq!(notes.len(), 2);
assert_eq!(notes[0].level, "help");
assert_eq!(notes[1].message, "expected `&str`, found `String`");
}
#[test]
fn ansi_is_stripped_for_the_in_window_banner() {
assert_eq!(
strip_ansi("\x1b[1;31merror\x1b[0m: mismatched types"),
"error: mismatched types"
);
}
fn points_at(text: &str, suffix: &str) -> bool {
text.replace('\\', "/").contains(suffix)
}
fn fake_package(tag: &str, rsx: &str, generated: &str, map: SourceMap) -> PathBuf {
let root = std::env::temp_dir().join(format!("telar_diag_{tag}_{}", std::process::id()));
let build = root.join(".telar/build-hot");
std::fs::create_dir_all(&build).unwrap();
std::fs::create_dir_all(root.join("src")).unwrap();
std::fs::write(root.join("src/home.rsx"), rsx).unwrap();
std::fs::write(build.join("home.rs"), generated).unwrap();
std::fs::write(build.join("home.rs.map"), map.to_json()).unwrap();
root
}
fn message_line(root: &Path, level: &str, message: &str, line: u64) -> String {
message_span(root, level, message, line, None)
}
fn message_span(
root: &Path,
level: &str,
message: &str,
line: u64,
bytes: Option<(u32, u32)>,
) -> String {
let mut span = serde_json::json!({
"file_name": root.join(".telar/build-hot/home.rs").to_str().unwrap(),
"line_start": line,
"is_primary": true,
});
if let Some((start, end)) = bytes {
span["byte_start"] = start.into();
span["byte_end"] = end.into();
}
serde_json::json!({
"reason": "compiler-message",
"message": {
"level": level,
"message": message,
"rendered": format!("{level}: {message}\n --> {}/.telar/build-hot/home.rs:{line}\n", root.display()),
"spans": [span],
},
})
.to_string()
}
#[test]
fn a_type_error_is_reported_against_the_rsx_line_not_the_generated_one() {
let root = fake_package(
"err",
"[logic]\nlet n = signal(0);\n\n[view]\ntext \"{n}\"\n",
"1\n2\n3\n4\n5\n let n = signal(0);\n",
SourceMap::new(vec![None, None, None, None, None, Some(1)], vec![]),
);
let report = collect(message_line(&root, "error", "mismatched types", 6).as_bytes());
let text = report.render(false);
assert!(text.contains("error: mismatched types"), "{text}");
assert!(points_at(&text, "src/home.rsx:2"), "{text}");
assert!(
text.contains("let n = signal(0);"),
"the frame quotes the line the author wrote:\n{text}"
);
assert!(
!text.contains(".telar"),
"and nothing points into the build directory:\n{text}"
);
std::fs::remove_dir_all(&root).ok();
}
#[test]
fn a_warning_is_not_silently_swallowed() {
let root = fake_package(
"warn",
"[logic]\nlet unused = 1;\n\n[view]\ncolumn\n",
"boilerplate\n let unused = 1;\n",
SourceMap::new(vec![None, Some(1)], vec![]),
);
let report = collect(message_line(&root, "warning", "unused variable: `unused`", 2).as_bytes());
assert!(
report.has_diagnostics(),
"a warning must reach the report, not be swallowed"
);
assert!(!report.has_errors(), "a warning does not fail the build");
let text = report.render(false);
assert!(text.contains("warning: unused variable"), "{text}");
assert!(points_at(&text, "src/home.rsx:2"), "{text}");
std::fs::remove_dir_all(&root).ok();
}
#[test]
fn a_diagnostic_about_hand_written_rust_is_passed_through_untouched() {
let message = serde_json::json!({
"reason": "compiler-message",
"message": {
"level": "error",
"message": "cannot find value `x`",
"rendered": "error: cannot find value `x`\n --> src/state.rs:9\n",
"spans": [{ "file_name": "src/state.rs", "line_start": 9, "is_primary": true }],
},
})
.to_string();
let text = collect(message.as_bytes()).render(false);
assert_eq!(text, "error: cannot find value `x`\n --> src/state.rs:9\n");
}
#[test]
fn a_missing_source_file_still_reports_the_diagnostic() {
let report = Report {
projected: vec![Projected {
source: PathBuf::from("/nowhere/home.rsx"),
line: 4,
underline: None,
level: "error".to_string(),
message: "mismatched types".to_string(),
notes: vec![],
}],
passthrough: vec![],
artifacts: vec![],
};
let text = report.render(false);
assert!(text.contains("error: mismatched types"), "{text}");
assert!(text.contains("/nowhere/home.rsx:4"), "{text}");
}
#[test]
fn a_logic_error_underlines_the_columns_rustc_gave_it() {
let generated = "fn home() {\n let count = signal(0);\n}\n";
let at = generated.find("count").unwrap() as u32;
let root = fake_package(
"cols",
"[logic]\nlet count = signal(0);\n\n[view]\ncolumn\n",
generated,
SourceMap::new(vec![None, Some(1), None], vec![]),
);
let text =
collect(message_span(&root, "error", "mismatched types", 2, Some((at, at + 5))).as_bytes())
.render(false);
assert!(points_at(&text, "src/home.rsx:2"), "{text}");
assert!(
text.contains(" ^^^^^"),
"the carets sit under `count`, four columns in:\n{text}"
);
std::fs::remove_dir_all(&root).ok();
}
#[test]
fn a_verbatim_view_expression_is_underlined_exactly() {
let rsx = "[view]\ncolumn\n text \"{missing}\"\n";
let generated = "fn home() {\n text(format!(\"{}\", missing))\n}\n";
let gen_at = generated.find("missing").unwrap() as u32;
let root = fake_package(
"verbatim",
rsx,
generated,
SourceMap::new(
vec![None, Some(2), None],
vec![telar_transpiler::ExprSpan {
rsx_start: rsx.find("missing").unwrap() as u32,
len: 7,
gen_start: gen_at,
}],
),
);
let text = collect(
message_span(
&root,
"error",
"cannot find value `missing`",
2,
Some((gen_at, gen_at + 7)),
)
.as_bytes(),
)
.render(false);
assert!(points_at(&text, "src/home.rsx:3"), "{text}");
assert!(
text.contains(&format!("{}^^^^^^^", " ".repeat(11))),
"the carets sit under `missing`, past ` text \"{{`:\n{text}"
);
std::fs::remove_dir_all(&root).ok();
}
#[test]
fn a_rewritten_view_line_is_not_underlined_at_all() {
let generated = "fn home() {\n Text::new(\"hi\")\n}\n";
let at = generated.find("Text").unwrap() as u32;
let root = fake_package(
"wide",
"[logic]\nlet x = 1;\n\n[view]\ntext \"hi\"\n",
generated,
SourceMap::new(vec![None, Some(4), None], vec![]),
);
let text =
collect(message_span(&root, "error", "no method `new`", 2, Some((at, at + 4))).as_bytes())
.render(false);
assert!(points_at(&text, "src/home.rsx:5"), "{text}");
assert!(
!text.contains('^'),
"nothing is underlined when the columns mean nothing:\n{text}"
);
std::fs::remove_dir_all(&root).ok();
}
fn transpiled_package(tag: &str, cargo: &str, telar: &str, rsx: &str) -> (PathBuf, String) {
let root = std::env::temp_dir().join(format!("telar_diag_{tag}_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("src")).unwrap();
std::fs::write(root.join("Cargo.toml"), cargo).unwrap();
std::fs::write(root.join("telar.toml"), telar).unwrap();
let prelude = telar_project::resolve_prelude(&root).unwrap();
let out = telar_transpiler::transpile_buffer(
&root.join("src/home.rsx"),
rsx,
&telar_transpiler::PackageOptions {
src_dir: &root.join("src"),
theme_type: None,
assets: None,
prelude: &prelude,
library: false,
flavour: telar_project::BuildFlavour::Plain,
},
)
.unwrap();
let package = fake_package(
tag,
rsx,
&out.rust_code,
SourceMap::new(out.source_map, out.expr_spans),
);
assert_eq!(package, root);
(root, out.rust_code)
}
fn rustc_error(
root: &Path,
generated: &str,
code: &str,
message: &str,
needle: &str,
children: serde_json::Value,
) -> String {
let start = generated
.find(needle)
.unwrap_or_else(|| panic!("`{needle}` is not in:\n{generated}"));
let line = generated[..start].matches('\n').count() + 1;
serde_json::json!({
"reason": "compiler-message",
"message": {
"level": "error",
"message": message,
"code": { "code": code, "explanation": null },
"rendered": format!("error[{code}]: {message}\n --> .telar/build-hot/home.rs:{line}\n"),
"spans": [{
"file_name": root.join(".telar/build-hot/home.rs").to_str().unwrap(),
"byte_start": start,
"byte_end": start + needle.trim_end_matches('(').len(),
"line_start": line,
"is_primary": true,
}],
"children": children,
},
})
.to_string()
}
fn suggestion(message: &str, replacement: &str) -> serde_json::Value {
serde_json::json!({
"level": "help",
"message": message,
"spans": [{ "suggested_replacement": replacement, "is_primary": true }],
"children": [],
})
}
fn glob_note(message: &str, path: &str) -> serde_json::Value {
let line = format!("#[allow(unused_imports)] use {path}::*;");
let at = line.find(&format!("{path}::*")).unwrap() + 1;
serde_json::json!({
"level": "note",
"message": message,
"spans": [{
"is_primary": true,
"text": [{
"text": line,
"highlight_start": at,
"highlight_end": at + path.len() + 3,
}],
}],
"children": [],
})
}
const DEPENDS_ON_COMPONENTS: &str =
"[package]\nname = \"app\"\n\n[dependencies]\ntelar = \"0.2\"\ntelar-components = \"0.2\"\n";
#[test]
fn an_unknown_tag_is_one_error_on_the_tag() {
let (root, generated) = transpiled_package(
"unknown_tag",
DEPENDS_ON_COMPONENTS,
"[telar]\nprelude = [\"telar-components\"]\n",
"[view]\ncolumn\n buton label:\"Go\"\n",
);
let stream = [
rustc_error(
&root,
&generated,
"E0433",
"cannot find type `ButonProps` in this scope",
"ButonProps",
serde_json::json!([suggestion(
"a struct with a similar name exists",
"ButtonProps"
)]),
),
rustc_error(
&root,
&generated,
"E0425",
"cannot find function `buton` in this scope",
"buton(",
serde_json::json!([suggestion(
"a function with a similar name exists",
"button"
)]),
),
]
.join("\n");
let text = collect(stream.as_bytes()).render(false);
std::fs::remove_dir_all(&root).ok();
assert_eq!(
text.matches("unknown tag").count(),
1,
"two rustc errors, one mistake:\n{text}"
);
assert!(
text.contains("error: unknown tag `buton`: not a built-in, not a `.rsx` in this package, and not exported by any `[telar] prelude` entry (`telar_components`)"),
"{text}"
);
assert!(points_at(&text, "src/home.rsx:3"), "{text}");
assert!(
text.contains("\n | ^^^^^\n"),
"the tag is underlined:\n{text}"
);
assert!(
text.contains("help: a function with a similar name exists: `button`"),
"{text}"
);
assert!(
!text.contains("ButtonProps") && !text.contains(".telar") && !text.contains("cannot find"),
"nothing about the Rust the tag became:\n{text}"
);
}
#[test]
fn a_tag_two_crates_export_names_both_and_the_use_that_settles_it() {
let (root, generated) = transpiled_package(
"clash",
DEPENDS_ON_COMPONENTS,
"[telar]\nprelude = [\"telar-components\"]\n",
"[view]\nbutton\n",
);
let ambiguous = |name: &str, kind: &str, needle: &str| {
rustc_error(
&root,
&generated,
"E0659",
&format!("`{name}` is ambiguous"),
needle,
serde_json::json!([
{ "level": "note", "message": "ambiguous because of multiple glob imports of a name in the same module", "spans": [], "children": [] },
glob_note(&format!("`{name}` could refer to the {kind} imported here"), "telar"),
{ "level": "help", "message": format!("consider adding an explicit import of `{name}` to disambiguate"), "spans": [], "children": [] },
glob_note(&format!("`{name}` could also refer to the {kind} imported here"), "telar_components"),
{ "level": "help", "message": format!("consider adding an explicit import of `{name}` to disambiguate"), "spans": [], "children": [] },
]),
)
};
let stream = [
ambiguous("button", "function", "button("),
ambiguous("ButtonProps", "struct", "ButtonProps"),
]
.join("\n");
let text = collect(stream.as_bytes()).render(false);
std::fs::remove_dir_all(&root).ok();
assert_eq!(text.matches("error:").count(), 1, "{text}");
assert!(
text.contains("error: tag `button` is exported by both `telar` and `telar_components`; pick one with `use telar::{button, ButtonProps};` in `[logic]`"),
"{text}"
);
assert!(points_at(&text, "src/home.rsx:2"), "{text}");
assert!(
!text.contains("could refer to") && !text.contains("explicit import"),
"rustc's notes point at generated imports:\n{text}"
);
}
#[test]
fn a_prelude_crate_that_is_not_a_dependency_is_one_error_on_its_telar_toml_line() {
let (root, generated) = transpiled_package(
"undeclared",
"[package]\nname = \"app\"\n\n[dependencies]\ntelar = \"0.2\"\n",
"[telar]\nprelude = [\"telar-components\"]\n",
"[view]\ntext \"hi\"\n",
);
let stream = rustc_error(
&root,
&generated,
"E0432",
"unresolved import `telar_components`",
"telar_components",
serde_json::json!([{ "level": "help", "message": "you might be missing a crate named `telar_components`", "spans": [], "children": [] }]),
);
let mut report = collect(stream.as_bytes());
report.add_prelude_problems(&telar_project::prelude_problems(&root).unwrap());
let text = report.render(false);
std::fs::remove_dir_all(&root).ok();
assert_eq!(text.matches("error:").count(), 1, "{text}");
assert!(
text.contains("error: `[telar] prelude` entry `telar_components` names `telar_components`, which is not a dependency of `app`"),
"{text}"
);
assert!(points_at(&text, "telar.toml:2"), "{text}");
assert!(
text.contains("\n | ^^^^^^^^^^^^^^^^^^\n"),
"the entry is underlined:\n{text}"
);
assert!(text.contains("cargo add -p app telar-components"), "{text}");
assert!(!text.contains(".telar/"), "{text}");
}
#[test]
fn a_previews_include_that_is_not_a_dependency_is_an_error_on_its_telar_toml_line() {
let root = std::env::temp_dir().join(format!("telar_diag_include_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
std::fs::write(
root.join("Cargo.toml"),
"[package]\nname = \"app\"\n\n[dependencies]\ntelar = \"0.2\"\n",
)
.unwrap();
std::fs::write(
root.join("telar.toml"),
"[telar.previews]\ninclude = [\"telar-components\"]\n",
)
.unwrap();
let mut report = Report::default();
report.add_previews_include_problems(&telar_project::previews_include_problems(&root).unwrap());
let text = report.render(false);
std::fs::remove_dir_all(&root).ok();
assert!(report.has_errors(), "{text}");
assert!(
text.contains("error: `[telar.previews] include` entry `telar_components` is not a dependency of `app`"),
"{text}"
);
assert!(points_at(&text, "telar.toml:2"), "{text}");
assert!(text.contains("cargo add -p app telar-components"), "{text}");
}
#[test]
fn a_prelude_path_that_does_not_resolve_is_reported_on_its_telar_toml_line() {
let (root, generated) = transpiled_package(
"unresolved_path",
DEPENDS_ON_COMPONENTS,
"[telar]\nprelude = [\"telar_components::prelud\"]\n",
"[view]\ntext \"hi\"\n",
);
let stream = rustc_error(
&root,
&generated,
"E0432",
"unresolved import `telar_components::prelud`",
"prelud::*",
serde_json::json!([]),
);
let text = collect(stream.as_bytes()).render(false);
std::fs::remove_dir_all(&root).ok();
assert!(
text.contains("error: `[telar] prelude` entry `telar_components::prelud` does not resolve: unresolved import `telar_components::prelud`"),
"{text}"
);
assert!(points_at(&text, "telar.toml:2"), "{text}");
}
#[test]
fn origin_reads_the_transpilers_map_beside_the_build_file() {
let built = SourceMap::new(vec![Some(0), Some(1)], Vec::new());
let root = fake_package("origin_map", "a\nb\n", "x\ny\n", built.clone());
let origin = Origin::read(&root.join(".telar/build-hot/home.rs")).unwrap();
assert_eq!(origin.map.to_json(), built.to_json());
assert!(!root.join(".telar/live").exists());
let _ = std::fs::remove_dir_all(&root);
}