use iced::Color;
use std::rc::Rc;
use std::sync::{Mutex, OnceLock};
use syntect::easy::HighlightLines;
use syntect::highlighting::{
HighlightState, Highlighter, RangedHighlightIterator, Style, ThemeSet,
};
use syntect::parsing::{
ParseState, ScopeStack, SyntaxDefinition, SyntaxReference, SyntaxSet,
SyntaxSetBuilder,
};
#[cfg(not(target_arch = "wasm32"))]
use std::time::Instant;
#[cfg(target_arch = "wasm32")]
use web_time::Instant;
use super::token_colors::TokenColorizer;
use crate::canvas_editor::{
CodeEditor, HIGHLIGHT_CLOCK_CHECK_INTERVAL, HighlightCache, ResolvedSyntax,
};
static SYNTAX_SET: OnceLock<SyntaxSet> = OnceLock::new();
static EXTRA_SYNTAXES: Mutex<Vec<SyntaxDefinition>> = Mutex::new(Vec::new());
static EXTRA_SET: OnceLock<SyntaxSet> = OnceLock::new();
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SyntaxRegistrationError {
Parse {
index: usize,
message: String,
},
AlreadyBuilt,
}
impl std::fmt::Display for SyntaxRegistrationError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Parse { index, message } => {
write!(f, "syntax definition {index}: {message}")
}
Self::AlreadyBuilt => write!(
f,
"the syntax set is already built; register syntaxes before \
the first editor highlights text"
),
}
}
}
impl std::error::Error for SyntaxRegistrationError {}
pub fn register_syntaxes<'a>(
definitions: impl IntoIterator<Item = &'a str>,
) -> Result<(), SyntaxRegistrationError> {
register_into(&EXTRA_SET, &EXTRA_SYNTAXES, definitions)
}
fn register_into<'a>(
set: &OnceLock<SyntaxSet>,
queue: &Mutex<Vec<SyntaxDefinition>>,
definitions: impl IntoIterator<Item = &'a str>,
) -> Result<(), SyntaxRegistrationError> {
let parsed = definitions
.into_iter()
.enumerate()
.map(|(index, text)| {
SyntaxDefinition::load_from_str(text, true, None).map_err(|e| {
SyntaxRegistrationError::Parse { index, message: e.to_string() }
})
})
.collect::<Result<Vec<_>, _>>()?;
let mut queue = queue.lock().unwrap_or_else(|e| e.into_inner());
if set.get().is_some() {
return Err(SyntaxRegistrationError::AlreadyBuilt);
}
queue.extend(parsed);
Ok(())
}
fn bundled_syntax_set() -> SyntaxSet {
#[cfg(feature = "two-face")]
{
two_face::syntax::extra_newlines()
}
#[cfg(not(feature = "two-face"))]
{
SyntaxSet::load_defaults_newlines()
}
}
fn build_extra_set(queue: &Mutex<Vec<SyntaxDefinition>>) -> SyntaxSet {
let mut builder = SyntaxSetBuilder::new();
let definitions =
std::mem::take(&mut *queue.lock().unwrap_or_else(|e| e.into_inner()));
for definition in definitions {
builder.add(definition);
}
builder.build()
}
fn find_registered<'a>(
set: &'a SyntaxSet,
name: &str,
) -> Option<&'a SyntaxReference> {
set.syntaxes().iter().rev().find(|syntax| {
syntax.file_extensions.iter().any(|e| e.eq_ignore_ascii_case(name))
})
}
static THEME_SET: OnceLock<ThemeSet> = OnceLock::new();
fn color_from_style(style: Style) -> Color {
color_from_syntect(style.foreground)
}
fn color_from_syntect(color: syntect::highlighting::Color) -> Color {
Color::from_rgb(
f32::from(color.r) / 255.0,
f32::from(color.g) / 255.0,
f32::from(color.b) / 255.0,
)
}
fn luminance(color: Color) -> f32 {
color.r * 0.299 + color.g * 0.587 + color.b * 0.114
}
const MIN_CONTRAST: f32 = 0.12;
fn contrasts_with(color: Color, background: Color) -> bool {
(luminance(color) - luminance(background)).abs() >= MIN_CONTRAST
}
fn readable_color(style: Style, background: Color, fallback: Color) -> Color {
let foreground = color_from_style(style);
if contrasts_with(foreground, background) {
return foreground;
}
let highlight = color_from_syntect(style.background);
if contrasts_with(highlight, background) {
return highlight;
}
fallback
}
pub fn highlight_line_spans(
line: &str,
syntax: &syntect::parsing::SyntaxReference,
theme: &syntect::highlighting::Theme,
syntax_set: &SyntaxSet,
) -> Vec<(Color, String)> {
let mut highlighter = HighlightLines::new(syntax, theme);
let ranges = highlighter
.highlight_line(line, syntax_set)
.unwrap_or_else(|_| vec![(Style::default(), line)]);
let background =
theme.settings.background.map_or(Color::BLACK, color_from_syntect);
let fallback =
theme.settings.foreground.map_or(Color::WHITE, color_from_syntect);
ranges
.into_iter()
.map(|(style, text)| {
(readable_color(style, background, fallback), text.to_string())
})
.collect()
}
const BRACKET_PAIR_COLORS_DARK: [Color; 3] = [
Color { r: 1.0, g: 0.843, b: 0.0, a: 1.0 }, Color { r: 0.855, g: 0.439, b: 0.839, a: 1.0 }, Color { r: 0.529, g: 0.808, b: 0.980, a: 1.0 }, ];
const BRACKET_PAIR_COLORS_LIGHT: [Color; 3] = [
Color { r: 0.016, g: 0.192, b: 0.980, a: 1.0 }, Color { r: 0.192, g: 0.576, b: 0.192, a: 1.0 }, Color { r: 0.482, g: 0.220, b: 0.078, a: 1.0 }, ];
impl CodeEditor {
pub(super) fn bracket_pair_colors(&self) -> &'static [Color; 3] {
if crate::theme::is_dark_background(self.style.background) {
&BRACKET_PAIR_COLORS_DARK
} else {
&BRACKET_PAIR_COLORS_LIGHT
}
}
pub(crate) fn resolve_syntax(
&self,
) -> (
&'static SyntaxSet,
Option<&'static SyntaxReference>,
Option<&'static syntect::highlighting::Theme>,
) {
let bundled = SYNTAX_SET.get_or_init(bundled_syntax_set);
let registered =
EXTRA_SET.get_or_init(|| build_extra_set(&EXTRA_SYNTAXES));
let owner = |syntax: Option<&'static SyntaxReference>| {
let is_registered = syntax.is_some_and(|s| {
registered.syntaxes().iter().any(|r| std::ptr::eq(r, s))
});
if is_registered { registered } else { bundled }
};
let dark_background =
crate::theme::is_dark_background(self.style.background);
let requested_theme = self.style.syntax_theme_name;
let mut memo = self.resolved_syntax.borrow_mut();
if let Some((syntax, theme)) = memo.as_ref().and_then(|resolved| {
resolved.get(&self.syntax, dark_background, requested_theme)
}) {
return (owner(syntax), syntax, theme);
}
let theme_set = THEME_SET.get_or_init(ThemeSet::load_defaults);
let automatic_theme = if dark_background {
"base16-ocean.dark"
} else {
"base16-ocean.light"
};
let theme = requested_theme
.and_then(|name| theme_set.themes.get(name))
.or_else(|| theme_set.themes.get(automatic_theme))
.or_else(|| theme_set.themes.values().next());
let syntax_set = bundled;
let syntax = find_registered(registered, &self.syntax)
.or_else(|| match self.syntax.as_str() {
"python" => syntax_set.find_syntax_by_extension("py"),
"rust" => syntax_set.find_syntax_by_extension("rs"),
"javascript" => syntax_set.find_syntax_by_extension("js"),
"htm" => syntax_set.find_syntax_by_extension("html"),
"svg" => syntax_set.find_syntax_by_extension("xml"),
"markdown" => syntax_set.find_syntax_by_extension("md"),
"text" => Some(syntax_set.find_syntax_plain_text()),
_ => syntax_set.find_syntax_by_extension(self.syntax.as_str()),
})
.or(Some(syntax_set.find_syntax_plain_text()));
*memo = Some(ResolvedSyntax::new(
&self.syntax,
dark_background,
requested_theme,
syntax,
theme,
));
(owner(syntax), syntax, theme)
}
pub(crate) fn highlighted_line_cached(
&self,
logical_line: usize,
syntax: &syntect::parsing::SyntaxReference,
theme: &syntect::highlighting::Theme,
syntax_set: &SyntaxSet,
) -> Rc<Vec<(Color, String)>> {
let mut guard = self.highlight_cache.borrow_mut();
let needs_reset =
guard.as_ref().is_none_or(|cache| cache.syntax() != self.syntax);
if needs_reset {
*guard = Some(HighlightCache::new(self.syntax.clone()));
}
let Some(cache) = guard.as_mut() else {
return Rc::new(highlight_line_spans(
self.buffer.line(logical_line),
syntax,
theme,
syntax_set,
));
};
if let Some(spans) = cache.spans(logical_line) {
return spans;
}
let highlighter = Highlighter::new(theme);
let (mut parse_state, mut highlight_state) =
cache.resume_state().unwrap_or_else(|| {
(
ParseState::new(syntax),
HighlightState::new(&highlighter, ScopeStack::new()),
)
});
let line_count = self.buffer.line_count();
let target = logical_line.min(line_count.saturating_sub(1));
let missing_lines =
target.saturating_add(1).saturating_sub(cache.valid_len());
let lines_to_parse =
missing_lines.min(self.highlight_lines_remaining.get());
let parse_end = cache
.valid_len()
.saturating_add(lines_to_parse)
.saturating_sub(1)
.min(target);
let mut result = None;
let background = self.style.background;
let fallback = self.style.text_color;
let deadline = self.highlight_deadline.get();
let mut parsed = 0usize;
if lines_to_parse > 0 {
for index in cache.valid_len()..=parse_end {
if parsed > 0
&& parsed.is_multiple_of(HIGHLIGHT_CLOCK_CHECK_INTERVAL)
&& deadline
.is_some_and(|deadline| Instant::now() >= deadline)
{
break;
}
parsed += 1;
let mut line = self.buffer.line(index).to_string();
line.push('\n');
let ops = parse_state
.parse_line(&line, syntax_set)
.unwrap_or_default();
let mut token_colors = TokenColorizer::new(
self.style.token_colors,
highlight_state.path.clone(),
&ops,
);
let spans: Vec<(Color, String)> = RangedHighlightIterator::new(
&mut highlight_state,
&ops,
&line,
&highlighter,
)
.filter_map(|(style, text, range)| {
let text = text.strip_suffix('\n').unwrap_or(text);
if text.is_empty() {
return None;
}
let color = token_colors
.as_mut()
.and_then(|colors| colors.color_at(range.start))
.unwrap_or_else(|| {
readable_color(style, background, fallback)
});
Some((color, text.to_string()))
})
.collect();
let spans = Rc::new(spans);
cache.push_line(
Rc::clone(&spans),
parse_state.clone(),
highlight_state.clone(),
);
if index == logical_line {
result = Some(spans);
}
}
}
self.highlight_lines_remaining
.set(self.highlight_lines_remaining.get().saturating_sub(parsed));
if cache.valid_len() <= target {
self.highlight_catch_up_pending.set(true);
}
result.or_else(|| cache.spans(logical_line)).unwrap_or_else(|| {
Rc::new(vec![(
self.style.text_color,
self.buffer.line(logical_line).to_string(),
)])
})
}
}
#[cfg(test)]
mod tests {
use std::rc::Rc;
use syntect::parsing::SyntaxSet;
use super::*;
#[test]
fn test_bracket_pair_colors_follow_the_editor_theme() {
let mut editor = CodeEditor::new("(a)", "rs");
editor.set_theme(crate::theme::from_iced_theme(&iced::Theme::Dark));
let dark = editor.bracket_pair_colors();
editor.set_theme(crate::theme::from_iced_theme(&iced::Theme::Light));
let light = editor.bracket_pair_colors();
assert_ne!(
dark[0], light[0],
"a light theme must not reuse the dark rainbow palette"
);
}
#[test]
fn test_bracket_pair_colors_contrast_with_their_background() {
for color in BRACKET_PAIR_COLORS_DARK {
assert!(
!crate::theme::is_dark_background(color),
"{color:?} is too dark for a dark background"
);
}
for color in BRACKET_PAIR_COLORS_LIGHT {
assert!(
crate::theme::is_dark_background(color),
"{color:?} is too light for a light background"
);
}
}
#[test]
fn test_highlight_line_spans_covers_full_line() {
let syntax_set = SyntaxSet::load_defaults_newlines();
let syntax = syntax_set.find_syntax_plain_text();
let theme = syntect::highlighting::Theme::default();
let line = "fn main() {}";
let spans = highlight_line_spans(line, syntax, &theme, &syntax_set);
assert!(!spans.is_empty(), "expected at least one span");
let combined: String =
spans.iter().map(|(_, text)| text.as_str()).collect();
assert_eq!(combined, line, "spans must cover the entire line");
}
#[test]
fn test_highlighted_line_cached_reuses_until_invalidated() {
let editor = CodeEditor::new("fn main() {}\nlet x = 1;", "rs");
let syntax_set = SyntaxSet::load_defaults_newlines();
let syntax = syntax_set.find_syntax_plain_text();
let theme = syntect::highlighting::Theme::default();
let first =
editor.highlighted_line_cached(0, syntax, &theme, &syntax_set);
let second =
editor.highlighted_line_cached(0, syntax, &theme, &syntax_set);
assert!(
Rc::ptr_eq(&first, &second),
"a cached line should be reused as the same Rc"
);
editor.invalidate_highlight_from(0);
let third =
editor.highlighted_line_cached(0, syntax, &theme, &syntax_set);
assert!(
!Rc::ptr_eq(&first, &third),
"invalidation should force the line to be recomputed"
);
}
#[test]
fn test_highlight_budget_uses_plain_fallback_without_scanning_to_target() {
let editor = CodeEditor::new("zero\none\ntwo\nthree\nfour", "txt");
let syntax_set = SyntaxSet::load_defaults_newlines();
let syntax = syntax_set.find_syntax_plain_text();
let theme = syntect::highlighting::Theme::default();
editor.highlight_lines_remaining.set(2);
let spans =
editor.highlighted_line_cached(4, syntax, &theme, &syntax_set);
let combined: String =
spans.iter().map(|(_, text)| text.as_str()).collect();
assert_eq!(combined, "four");
assert_eq!(
editor
.highlight_cache
.borrow()
.as_ref()
.map(super::HighlightCache::valid_len),
Some(2)
);
assert_eq!(editor.highlight_lines_remaining.get(), 0);
}
#[test]
fn test_expired_time_budget_stops_parsing_early() {
let content = vec!["{\"k\": 1}"; 1_000].join("\n");
let editor = CodeEditor::new(&content, "json");
let (syntax_set, syntax, theme) = editor.resolve_syntax();
let (Some(syntax), Some(theme)) = (syntax, theme) else {
return;
};
editor.highlight_lines_remaining.set(10_000);
editor.highlight_deadline.set(Some(Instant::now()));
let _ = editor.highlighted_line_cached(999, syntax, theme, syntax_set);
let parsed = editor
.highlight_cache
.borrow()
.as_ref()
.map(super::HighlightCache::valid_len);
assert_eq!(
parsed,
Some(HIGHLIGHT_CLOCK_CHECK_INTERVAL),
"parsing stops at the first clock check past the deadline"
);
assert_eq!(
editor.highlight_lines_remaining.get(),
10_000 - HIGHLIGHT_CLOCK_CHECK_INTERVAL,
"only the lines actually parsed are charged"
);
assert!(editor.highlight_catch_up_pending.get());
}
#[test]
fn test_no_deadline_parses_up_to_the_target() {
let content = vec!["{\"k\": 1}"; 1_000].join("\n");
let editor = CodeEditor::new(&content, "json");
let (syntax_set, syntax, theme) = editor.resolve_syntax();
let (Some(syntax), Some(theme)) = (syntax, theme) else {
return;
};
let _ = editor.highlighted_line_cached(999, syntax, theme, syntax_set);
assert!(!editor.highlight_catch_up_pending.get());
assert_eq!(
editor
.highlight_cache
.borrow()
.as_ref()
.map(super::HighlightCache::valid_len),
Some(1_000)
);
}
fn test_luminance(color: Color) -> f32 {
color.r * 0.299 + color.g * 0.587 + color.b * 0.114
}
fn assert_all_spans_legible(code: &str, syntax_name: &str) {
for iced_theme in [iced::Theme::Dark, iced::Theme::Light] {
let mut editor = CodeEditor::new(code, syntax_name);
editor.set_theme(crate::theme::from_iced_theme(&iced_theme));
let (syntax_set, syntax, theme) = editor.resolve_syntax();
let (Some(syntax), Some(theme)) = (syntax, theme) else {
continue;
};
let background = test_luminance(editor.style.background);
for line in 0..editor.buffer.line_count() {
let spans = editor
.highlighted_line_cached(line, syntax, theme, syntax_set);
for (color, text) in spans.iter() {
let contrast = (test_luminance(*color) - background).abs();
assert!(
contrast >= 0.12,
"{iced_theme:?}: {text:?} on line {line} is drawn in \
{color:?}, which vanishes into the background"
);
}
}
}
}
#[test]
fn test_invalid_json_tokens_stay_legible() {
assert_all_spans_legible("{\n \"a\": 1,,\n \"b\" 2\n}}\n]", "json");
}
#[test]
fn test_valid_code_keeps_distinct_theme_colors() {
let editor = CodeEditor::new("{\"key\": \"value\", \"n\": 42}", "json");
let (syntax_set, syntax, theme) = editor.resolve_syntax();
let (Some(syntax), Some(theme)) = (syntax, theme) else {
return;
};
let spans =
editor.highlighted_line_cached(0, syntax, theme, syntax_set);
let mut colors: Vec<Color> = Vec::new();
for (color, _) in spans.iter() {
if !colors.contains(color) {
colors.push(*color);
}
}
assert!(colors.len() >= 3, "expected varied token colors: {colors:?}");
assert_all_spans_legible("{\"key\": \"value\", \"n\": 42}", "json");
}
#[test]
fn test_highlighted_line_cached_handles_multiline_comments() {
let syntax_set = SyntaxSet::load_defaults_newlines();
let syntax = syntax_set
.find_syntax_by_extension("rs")
.unwrap_or_else(|| syntax_set.find_syntax_plain_text());
let theme = ThemeSet::load_defaults()
.themes
.get("base16-ocean.dark")
.cloned()
.unwrap_or_default();
let code = "let a = 1;\n/* open\nstill inside\n*/\nlet b = 2;";
let editor = CodeEditor::new(code, "rs");
let sequential =
editor.highlighted_line_cached(2, syntax, &theme, &syntax_set);
let independent = highlight_line_spans(
editor.buffer.line(2),
syntax,
&theme,
&syntax_set,
);
let sequential_color = sequential.first().map(|(color, _)| *color);
let independent_color = independent.first().map(|(color, _)| *color);
assert!(sequential_color.is_some());
assert!(independent_color.is_some());
assert_ne!(
sequential_color, independent_color,
"a line inside a block comment must be colored as a comment"
);
}
const TINY: &str = r#"
name: Tiny
file_extensions: [tiny]
scope: source.tiny
contexts:
main:
- match: '\bhello\b'
scope: keyword.tiny
"#;
#[test]
#[allow(clippy::unwrap_used, clippy::expect_used)]
fn registered_syntaxes_are_found_by_extension() {
let set = OnceLock::new();
let queue = Mutex::new(Vec::new());
register_into(&set, &queue, [TINY]).expect("valid");
let built = set.get_or_init(|| build_extra_set(&queue));
assert!(queue.lock().unwrap().is_empty(), "the queue is consumed");
let tiny = find_registered(built, "TINY").expect("registered");
assert_eq!(tiny.name, "Tiny");
assert!(find_registered(built, "rs").is_none());
let spans = highlight_line_spans(
"say hello",
tiny,
&syntect::highlighting::Theme::default(),
built,
);
let texts: Vec<_> = spans.iter().map(|(_, t)| t.as_str()).collect();
assert_eq!(texts.concat(), "say hello");
}
#[test]
#[allow(clippy::unwrap_used, clippy::expect_used)]
fn registered_syntaxes_include_each_other_and_the_last_one_wins() {
let host = r#"
name: Host
file_extensions: [host]
scope: source.host
contexts:
main:
- include: scope:source.tiny
"#;
let newer_tiny = TINY.replace("name: Tiny", "name: Newer Tiny");
let set = OnceLock::new();
let queue = Mutex::new(Vec::new());
register_into(&set, &queue, [TINY, host, newer_tiny.as_str()])
.expect("valid");
let built = set.get_or_init(|| build_extra_set(&queue));
assert_eq!(find_registered(built, "tiny").unwrap().name, "Newer Tiny");
let host = find_registered(built, "host").unwrap();
let mut state = ParseState::new(host);
let ops = state.parse_line("hello\n", built).expect("parses");
assert!(!ops.is_empty(), "the included grammar colors the word");
}
#[test]
#[allow(clippy::unwrap_used, clippy::expect_used)]
fn invalid_definitions_and_late_registration_are_rejected() {
let set = OnceLock::new();
let queue = Mutex::new(Vec::new());
let error = register_into(&set, &queue, [TINY, "name: [unclosed"])
.expect_err("invalid");
assert!(matches!(
error,
SyntaxRegistrationError::Parse { index: 1, .. }
));
assert!(queue.lock().unwrap().is_empty(), "all or nothing");
set.get_or_init(|| build_extra_set(&queue));
assert_eq!(
register_into(&set, &queue, [TINY]),
Err(SyntaxRegistrationError::AlreadyBuilt)
);
}
#[test]
#[allow(clippy::unwrap_used, clippy::expect_used)]
fn an_include_of_a_missing_syntax_does_not_panic() {
let dangling = r#"
name: Dangling
file_extensions: [dangling]
scope: source.dangling
contexts:
main:
- include: scope:source.rust
- match: '\bok\b'
scope: keyword.dangling
"#;
let set = OnceLock::new();
let queue = Mutex::new(Vec::new());
register_into(&set, &queue, [dangling]).expect("valid");
let built = set.get_or_init(|| build_extra_set(&queue));
let syntax = find_registered(built, "dangling").expect("registered");
let mut state = ParseState::new(syntax);
let _ = state.parse_line("ok then\n", built);
}
#[test]
fn with_nothing_registered_the_extra_set_is_empty() {
let queue = Mutex::new(Vec::new());
assert!(build_extra_set(&queue).syntaxes().is_empty());
}
}