From 8ff1e3ab7b60694cd402e47e68ad954d702ff898 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Tue, 3 Sep 2024 19:57:18 +0100
Subject: [PATCH 01/13] Add: xtask to check themes for validation warnings

---
 .github/workflows/build.yml |  3 ++
 Cargo.lock                  |  2 ++
 xtask/Cargo.toml            |  2 ++
 xtask/src/main.rs           |  7 ++++
 xtask/src/path.rs           |  4 +++
 xtask/src/theme_check.rs    | 71 +++++++++++++++++++++++++++++++++++++
 6 files changed, 89 insertions(+)
 create mode 100644 xtask/src/theme_check.rs

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 93fcb98164df..ef69a7c59dff 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -107,6 +107,9 @@ jobs:
       - name: Validate queries
         run: cargo xtask query-check
 
+      - name: Validate themes
+        run: cargo xtask theme-check
+
       - name: Generate docs
         run: cargo xtask docgen
 
diff --git a/Cargo.lock b/Cargo.lock
index d2f90669816b..500a16fda01a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2910,6 +2910,8 @@ dependencies = [
  "helix-loader",
  "helix-term",
  "helix-view",
+ "log",
+ "once_cell",
  "toml",
 ]
 
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index 25d8955e5a1f..0b6befb83bc4 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -17,3 +17,5 @@ helix-core = { path = "../helix-core" }
 helix-view = { path = "../helix-view" }
 helix-loader = { path = "../helix-loader" }
 toml = "0.8"
+log = "~0.4"
+once_cell = "1.19"
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index aba5c449985e..fcb462f252d5 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -2,6 +2,7 @@ mod docgen;
 mod helpers;
 mod path;
 mod querycheck;
+mod theme_check;
 
 use std::{env, error::Error};
 
@@ -11,6 +12,7 @@ pub mod tasks {
     use crate::docgen::{lang_features, typable_commands, write};
     use crate::docgen::{LANG_SUPPORT_MD_OUTPUT, TYPABLE_COMMANDS_MD_OUTPUT};
     use crate::querycheck::query_check;
+    use crate::theme_check::theme_check;
     use crate::DynError;
 
     pub fn docgen() -> Result<(), DynError> {
@@ -23,6 +25,10 @@ pub mod tasks {
         query_check()
     }
 
+    pub fn themecheck() -> Result<(), DynError> {
+        theme_check()
+    }
+
     pub fn print_help() {
         println!(
             "
@@ -43,6 +49,7 @@ fn main() -> Result<(), DynError> {
         Some(t) => match t.as_str() {
             "docgen" => tasks::docgen()?,
             "query-check" => tasks::querycheck()?,
+            "theme-check" => tasks::themecheck()?,
             invalid => return Err(format!("Invalid task name: {}", invalid).into()),
         },
     };
diff --git a/xtask/src/path.rs b/xtask/src/path.rs
index 62d884f2eed8..6f4545c274aa 100644
--- a/xtask/src/path.rs
+++ b/xtask/src/path.rs
@@ -18,3 +18,7 @@ pub fn ts_queries() -> PathBuf {
 pub fn lang_config() -> PathBuf {
     project_root().join("languages.toml")
 }
+
+pub fn themes() -> PathBuf {
+    project_root().join("runtime/themes")
+}
diff --git a/xtask/src/theme_check.rs b/xtask/src/theme_check.rs
new file mode 100644
index 000000000000..8bbd896542e6
--- /dev/null
+++ b/xtask/src/theme_check.rs
@@ -0,0 +1,71 @@
+use std::sync::{Arc, Mutex};
+
+use helix_view::theme::Loader;
+use log;
+
+use crate::{path, DynError};
+use once_cell::sync::Lazy;
+
+static LOGGER: Lazy<MockLog> = Lazy::new(|| MockLog::new());
+
+pub fn theme_check() -> Result<(), DynError> {
+    log::set_logger(&*LOGGER).unwrap();
+    log::set_max_level(log::LevelFilter::Warn);
+
+    let theme_names = Loader::read_names(&path::themes());
+    let loader = Loader::new(&vec![path::project_root().join("runtime")]);
+
+    let mut issues_found = false;
+    for name in theme_names {
+        let _ = loader.load(&name).unwrap();
+
+        {
+            let warnings = LOGGER.warnings.lock().unwrap();
+            if !warnings.is_empty() {
+                issues_found = true;
+
+                println!("Theme '{name}' loaded with warnings:");
+                for warning in warnings.iter() {
+                    println!("{warning}");
+                }
+            }
+        }
+
+        LOGGER.clear();
+    }
+    match issues_found {
+        true => Err("Issues found in bundled themes".to_string().into()),
+        false => Ok(()),
+    }
+}
+
+struct MockLog {
+    warnings: Arc<Mutex<Vec<String>>>,
+}
+
+impl MockLog {
+    pub fn new() -> Self {
+        MockLog {
+            warnings: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+
+    pub fn clear(&self) {
+        let mut warnings = self.warnings.lock().unwrap();
+        warnings.clear();
+    }
+}
+
+impl log::Log for MockLog {
+    fn enabled(&self, _metadata: &log::Metadata) -> bool {
+        true
+    }
+
+    fn log(&self, record: &log::Record) {
+        let mut warnings = self.warnings.lock().unwrap();
+        warnings.push(record.args().to_string());
+    }
+
+    fn flush(&self) { // Do nothing
+    }
+}

From ce7875baa2fa56be850d6f9b977ff69d5af64373 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Tue, 3 Sep 2024 20:04:10 +0100
Subject: [PATCH 02/13] Update: tidied up runtime paths

---
 xtask/src/path.rs        | 14 +++++++++-----
 xtask/src/theme_check.rs |  3 ++-
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/xtask/src/path.rs b/xtask/src/path.rs
index 6f4545c274aa..cf8e8792e9b1 100644
--- a/xtask/src/path.rs
+++ b/xtask/src/path.rs
@@ -11,14 +11,18 @@ pub fn book_gen() -> PathBuf {
     project_root().join("book/src/generated/")
 }
 
-pub fn ts_queries() -> PathBuf {
-    project_root().join("runtime/queries")
+pub fn runtime() -> PathBuf {
+    project_root().join("runtime")
 }
 
-pub fn lang_config() -> PathBuf {
-    project_root().join("languages.toml")
+pub fn ts_queries() -> PathBuf {
+    runtime().join("queries")
 }
 
 pub fn themes() -> PathBuf {
-    project_root().join("runtime/themes")
+    runtime().join("themes")
+}
+
+pub fn lang_config() -> PathBuf {
+    project_root().join("languages.toml")
 }
diff --git a/xtask/src/theme_check.rs b/xtask/src/theme_check.rs
index 8bbd896542e6..b1af3dabc434 100644
--- a/xtask/src/theme_check.rs
+++ b/xtask/src/theme_check.rs
@@ -13,7 +13,7 @@ pub fn theme_check() -> Result<(), DynError> {
     log::set_max_level(log::LevelFilter::Warn);
 
     let theme_names = Loader::read_names(&path::themes());
-    let loader = Loader::new(&vec![path::project_root().join("runtime")]);
+    let loader = Loader::new(&vec![path::runtime()]);
 
     let mut issues_found = false;
     for name in theme_names {
@@ -28,6 +28,7 @@ pub fn theme_check() -> Result<(), DynError> {
                 for warning in warnings.iter() {
                     println!("{warning}");
                 }
+                println!("\n");
             }
         }
 

From 9ed491a2eb19eb58448b202275676942f72f7756 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Tue, 3 Sep 2024 20:05:44 +0100
Subject: [PATCH 03/13] Update: test build workflow

---
 .github/workflows/build.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index ef69a7c59dff..75fd00279d0c 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -2,8 +2,8 @@ name: Build
 on:
   pull_request:
   push:
-    branches:
-      - master
+    # branches:
+    #   - master
   merge_group:
   schedule:
     - cron: "00 01 * * *"
@@ -16,6 +16,7 @@ jobs:
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
+
       - name: Install stable toolchain
         uses: dtolnay/rust-toolchain@1.70
 

From af5c69ad0ddc364ccc80b392d4ae7cce7fd8b775 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Tue, 3 Sep 2024 20:13:20 +0100
Subject: [PATCH 04/13] Update: address clippy lints

---
 xtask/src/theme_check.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/xtask/src/theme_check.rs b/xtask/src/theme_check.rs
index b1af3dabc434..878220561d5b 100644
--- a/xtask/src/theme_check.rs
+++ b/xtask/src/theme_check.rs
@@ -1,19 +1,18 @@
 use std::sync::{Arc, Mutex};
 
 use helix_view::theme::Loader;
-use log;
 
 use crate::{path, DynError};
 use once_cell::sync::Lazy;
 
-static LOGGER: Lazy<MockLog> = Lazy::new(|| MockLog::new());
+static LOGGER: Lazy<MockLog> = Lazy::new(MockLog::new);
 
 pub fn theme_check() -> Result<(), DynError> {
     log::set_logger(&*LOGGER).unwrap();
     log::set_max_level(log::LevelFilter::Warn);
 
     let theme_names = Loader::read_names(&path::themes());
-    let loader = Loader::new(&vec![path::runtime()]);
+    let loader = Loader::new(&[path::runtime()]);
 
     let mut issues_found = false;
     for name in theme_names {
@@ -28,7 +27,6 @@ pub fn theme_check() -> Result<(), DynError> {
                 for warning in warnings.iter() {
                     println!("{warning}");
                 }
-                println!("\n");
             }
         }
 

From 232f8e4c60667bb594fe80e8919f04be38d319f6 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Tue, 3 Sep 2024 20:17:20 +0100
Subject: [PATCH 05/13] Revert: only trigger workflow on push to master branch

---
 .github/workflows/build.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 75fd00279d0c..c9f198d0c71e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -2,8 +2,8 @@ name: Build
 on:
   pull_request:
   push:
-    # branches:
-    #   - master
+    branches:
+      - master
   merge_group:
   schedule:
     - cron: "00 01 * * *"

From 34c6a353e5b3b925a9c87f89a12751fd8e4346a9 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Wed, 4 Sep 2024 20:43:18 +0100
Subject: [PATCH 06/13] Add: Theme::from_keys factory method to construct theme
 from Toml keys

---
 Cargo.lock               |  2 --
 helix-view/src/theme.rs  | 50 ++++++++++++++++-----------
 xtask/Cargo.toml         |  2 --
 xtask/src/theme_check.rs | 73 ++++++++++------------------------------
 4 files changed, 48 insertions(+), 79 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 500a16fda01a..d2f90669816b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2910,8 +2910,6 @@ dependencies = [
  "helix-loader",
  "helix-term",
  "helix-view",
- "log",
- "once_cell",
  "toml",
 ]
 
diff --git a/helix-view/src/theme.rs b/helix-view/src/theme.rs
index 4acc56648aa0..fc628bfad835 100644
--- a/helix-view/src/theme.rs
+++ b/helix-view/src/theme.rs
@@ -221,14 +221,11 @@ pub struct Theme {
 impl From<Value> for Theme {
     fn from(value: Value) -> Self {
         if let Value::Table(table) = value {
-            let (styles, scopes, highlights) = build_theme_values(table);
-
-            Self {
-                styles,
-                scopes,
-                highlights,
-                ..Default::default()
+            let (theme, validation_failures) = Theme::from_keys(table);
+            for validation_failure in validation_failures {
+                warn!("{}", validation_failure);
             }
+            theme
         } else {
             warn!("Expected theme TOML value to be a table, found {:?}", value);
             Default::default()
@@ -242,31 +239,29 @@ impl<'de> Deserialize<'de> for Theme {
         D: Deserializer<'de>,
     {
         let values = Map::<String, Value>::deserialize(deserializer)?;
-
-        let (styles, scopes, highlights) = build_theme_values(values);
-
-        Ok(Self {
-            styles,
-            scopes,
-            highlights,
-            ..Default::default()
-        })
+        let (theme, validation_failures) = Theme::from_keys(values);
+        for validation_failure in validation_failures {
+            warn!("{}", validation_failure);
+        }
+        Ok(theme)
     }
 }
 
 fn build_theme_values(
     mut values: Map<String, Value>,
-) -> (HashMap<String, Style>, Vec<String>, Vec<Style>) {
+) -> (HashMap<String, Style>, Vec<String>, Vec<Style>, Vec<String>) {
     let mut styles = HashMap::new();
     let mut scopes = Vec::new();
     let mut highlights = Vec::new();
 
+    let mut validation_failures = Vec::new();
+
     // TODO: alert user of parsing failures in editor
     let palette = values
         .remove("palette")
         .map(|value| {
             ThemePalette::try_from(value).unwrap_or_else(|err| {
-                warn!("{}", err);
+                validation_failures.push(err);
                 ThemePalette::default()
             })
         })
@@ -279,7 +274,7 @@ fn build_theme_values(
     for (name, style_value) in values {
         let mut style = Style::default();
         if let Err(err) = palette.parse_style(&mut style, style_value) {
-            warn!("{}", err);
+            validation_failures.push(err);
         }
 
         // these are used both as UI and as highlights
@@ -288,10 +283,25 @@ fn build_theme_values(
         highlights.push(style);
     }
 
-    (styles, scopes, highlights)
+    (styles, scopes, highlights, validation_failures)
 }
 
 impl Theme {
+    /// Construct a Theme instance from a map of Toml keys
+    /// If any validation issues are encountered due the theme containing
+    /// invalid style definitions, the details are returned
+    pub fn from_keys(toml_keys: Map<String, Value>) -> (Self, Vec<String>) {
+        let (styles, scopes, highlights, validation_failures) = build_theme_values(toml_keys);
+
+        let theme = Self {
+            styles,
+            scopes,
+            highlights,
+            ..Default::default()
+        };
+        (theme, validation_failures)
+    }
+
     #[inline]
     pub fn highlight(&self, index: usize) -> Style {
         self.highlights[index]
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index 0b6befb83bc4..25d8955e5a1f 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -17,5 +17,3 @@ helix-core = { path = "../helix-core" }
 helix-view = { path = "../helix-view" }
 helix-loader = { path = "../helix-loader" }
 toml = "0.8"
-log = "~0.4"
-once_cell = "1.19"
diff --git a/xtask/src/theme_check.rs b/xtask/src/theme_check.rs
index 878220561d5b..3a153861f0b6 100644
--- a/xtask/src/theme_check.rs
+++ b/xtask/src/theme_check.rs
@@ -1,70 +1,33 @@
-use std::sync::{Arc, Mutex};
+use std::fs;
 
-use helix_view::theme::Loader;
+use helix_view::{theme::Loader, Theme};
 
 use crate::{path, DynError};
-use once_cell::sync::Lazy;
-
-static LOGGER: Lazy<MockLog> = Lazy::new(MockLog::new);
 
 pub fn theme_check() -> Result<(), DynError> {
-    log::set_logger(&*LOGGER).unwrap();
-    log::set_max_level(log::LevelFilter::Warn);
-
     let theme_names = Loader::read_names(&path::themes());
-    let loader = Loader::new(&[path::runtime()]);
+    let mut failures_found = false;
 
-    let mut issues_found = false;
     for name in theme_names {
-        let _ = loader.load(&name).unwrap();
-
-        {
-            let warnings = LOGGER.warnings.lock().unwrap();
-            if !warnings.is_empty() {
-                issues_found = true;
-
-                println!("Theme '{name}' loaded with warnings:");
-                for warning in warnings.iter() {
-                    println!("{warning}");
-                }
+        let path = path::themes().join(format!("{name}.toml"));
+        let content = fs::read_to_string(path).unwrap();
+        let toml = toml::from_str(&content).unwrap();
+        let (_, validation_failures) = Theme::from_keys(toml);
+
+        if !validation_failures.is_empty() {
+            failures_found = true;
+            println!("Theme '{name}' loaded with warnings:");
+            for failure in validation_failures {
+                println!("\t* {failure}");
             }
         }
-
-        LOGGER.clear();
     }
-    match issues_found {
-        true => Err("Issues found in bundled themes".to_string().into()),
-        false => Ok(()),
-    }
-}
-
-struct MockLog {
-    warnings: Arc<Mutex<Vec<String>>>,
-}
 
-impl MockLog {
-    pub fn new() -> Self {
-        MockLog {
-            warnings: Arc::new(Mutex::new(Vec::new())),
+    match failures_found {
+        true => Err("Validation failures found in bundled themes".into()),
+        false => {
+            println!("Theme check successful!");
+            Ok(())
         }
     }
-
-    pub fn clear(&self) {
-        let mut warnings = self.warnings.lock().unwrap();
-        warnings.clear();
-    }
-}
-
-impl log::Log for MockLog {
-    fn enabled(&self, _metadata: &log::Metadata) -> bool {
-        true
-    }
-
-    fn log(&self, record: &log::Record) {
-        let mut warnings = self.warnings.lock().unwrap();
-        warnings.push(record.args().to_string());
-    }
-
-    fn flush(&self) { // Do nothing
-    }
 }

From c5c19c245e4aa8b1e1421ea24b79a32969c778e8 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Wed, 4 Sep 2024 22:24:52 +0100
Subject: [PATCH 07/13] Update: returning validation failures in Loader.load
 method

---
 helix-term/src/application.rs    | 12 ++++++
 helix-term/src/commands/typed.rs | 11 +++++-
 helix-view/src/theme.rs          | 63 ++++++++++++++++----------------
 xtask/src/theme_check.rs         | 10 ++---
 4 files changed, 57 insertions(+), 39 deletions(-)

diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index bd6b5a870e3d..3173917d8b0c 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -120,6 +120,12 @@ impl Application {
                         log::warn!("failed to load theme `{}` - {}", theme, e);
                         e
                     })
+                    .map(|(theme, validation_failures)| {
+                        for validation_failure in validation_failures {
+                            log::warn!("{validation_failure}");
+                        }
+                        theme
+                    })
                     .ok()
                     .filter(|theme| (true_color || theme.is_16_color()))
             })
@@ -435,6 +441,12 @@ impl Application {
                         log::warn!("failed to load theme `{}` - {}", theme, e);
                         e
                     })
+                    .map(|(theme, validation_failures)| {
+                        for validation_failure in validation_failures {
+                            log::warn!("{validation_failure}");
+                        }
+                        theme
+                    })
                     .ok()
                     .filter(|theme| (true_color || theme.is_16_color()))
             })
diff --git a/helix-term/src/commands/typed.rs b/helix-term/src/commands/typed.rs
index 7ad0369fc1bd..5abd7f69bb21 100644
--- a/helix-term/src/commands/typed.rs
+++ b/helix-term/src/commands/typed.rs
@@ -879,10 +879,13 @@ fn theme(
                 // Ensures that a preview theme gets cleaned up if the user backspaces until the prompt is empty.
                 cx.editor.unset_theme_preview();
             } else if let Some(theme_name) = args.first() {
-                if let Ok(theme) = cx.editor.theme_loader.load(theme_name) {
+                if let Ok((theme, validation_failures)) = cx.editor.theme_loader.load(theme_name) {
                     if !(true_color || theme.is_16_color()) {
                         bail!("Unsupported theme: theme requires true color support");
                     }
+                    for validation_failure in validation_failures {
+                        log::warn!("{validation_failure}");
+                    }
                     cx.editor.set_theme_preview(theme);
                 };
             };
@@ -893,6 +896,12 @@ fn theme(
                     .editor
                     .theme_loader
                     .load(theme_name)
+                    .map(|(theme, validation_failures)| {
+                        for validation_failure in validation_failures {
+                            log::warn!("{validation_failure}");
+                        }
+                        theme
+                    })
                     .map_err(|err| anyhow::anyhow!("Could not load theme: {}", err))?;
                 if !(true_color || theme.is_16_color()) {
                     bail!("Unsupported theme: theme requires true color support");
diff --git a/helix-view/src/theme.rs b/helix-view/src/theme.rs
index fc628bfad835..6b46c41896f9 100644
--- a/helix-view/src/theme.rs
+++ b/helix-view/src/theme.rs
@@ -52,21 +52,24 @@ impl Loader {
     }
 
     /// Loads a theme searching directories in priority order.
-    pub fn load(&self, name: &str) -> Result<Theme> {
+    pub fn load(&self, name: &str) -> Result<(Theme, Vec<String>)> {
         if name == "default" {
-            return Ok(self.default());
+            return Ok((self.default(), Vec::new()));
         }
         if name == "base16_default" {
-            return Ok(self.base16_default());
+            return Ok((self.base16_default(), Vec::new()));
         }
 
         let mut visited_paths = HashSet::new();
-        let theme = self.load_theme(name, &mut visited_paths).map(Theme::from)?;
+        let (theme, validation_failures) = self
+            .load_theme(name, &mut visited_paths)
+            .map(Theme::from_toml)?;
 
-        Ok(Theme {
+        let theme = Theme {
             name: name.into(),
             ..theme
-        })
+        };
+        Ok((theme, validation_failures))
     }
 
     /// Recursively load a theme, merging with any inherited parent themes.
@@ -220,16 +223,8 @@ pub struct Theme {
 
 impl From<Value> for Theme {
     fn from(value: Value) -> Self {
-        if let Value::Table(table) = value {
-            let (theme, validation_failures) = Theme::from_keys(table);
-            for validation_failure in validation_failures {
-                warn!("{}", validation_failure);
-            }
-            theme
-        } else {
-            warn!("Expected theme TOML value to be a table, found {:?}", value);
-            Default::default()
-        }
+        let (theme, _) = Theme::from_toml(value);
+        theme
     }
 }
 
@@ -287,21 +282,6 @@ fn build_theme_values(
 }
 
 impl Theme {
-    /// Construct a Theme instance from a map of Toml keys
-    /// If any validation issues are encountered due the theme containing
-    /// invalid style definitions, the details are returned
-    pub fn from_keys(toml_keys: Map<String, Value>) -> (Self, Vec<String>) {
-        let (styles, scopes, highlights, validation_failures) = build_theme_values(toml_keys);
-
-        let theme = Self {
-            styles,
-            scopes,
-            highlights,
-            ..Default::default()
-        };
-        (theme, validation_failures)
-    }
-
     #[inline]
     pub fn highlight(&self, index: usize) -> Style {
         self.highlights[index]
@@ -364,6 +344,27 @@ impl Theme {
                 .all(|color| !matches!(color, Some(Color::Rgb(..))))
         })
     }
+
+    fn from_toml(value: Value) -> (Self, Vec<String>) {
+        if let Value::Table(table) = value {
+            Theme::from_keys(table)
+        } else {
+            warn!("Expected theme TOML value to be a table, found {:?}", value);
+            Default::default()
+        }
+    }
+
+    fn from_keys(toml_keys: Map<String, Value>) -> (Self, Vec<String>) {
+        let (styles, scopes, highlights, validation_failures) = build_theme_values(toml_keys);
+
+        let theme = Self {
+            styles,
+            scopes,
+            highlights,
+            ..Default::default()
+        };
+        (theme, validation_failures)
+    }
 }
 
 struct ThemePalette {
diff --git a/xtask/src/theme_check.rs b/xtask/src/theme_check.rs
index 3a153861f0b6..3edbde5024cc 100644
--- a/xtask/src/theme_check.rs
+++ b/xtask/src/theme_check.rs
@@ -1,18 +1,14 @@
-use std::fs;
-
-use helix_view::{theme::Loader, Theme};
+use helix_view::theme::Loader;
 
 use crate::{path, DynError};
 
 pub fn theme_check() -> Result<(), DynError> {
     let theme_names = Loader::read_names(&path::themes());
+    let loader = Loader::new(&[path::runtime()]);
     let mut failures_found = false;
 
     for name in theme_names {
-        let path = path::themes().join(format!("{name}.toml"));
-        let content = fs::read_to_string(path).unwrap();
-        let toml = toml::from_str(&content).unwrap();
-        let (_, validation_failures) = Theme::from_keys(toml);
+        let (_, validation_failures) = loader.load(&name).unwrap();
 
         if !validation_failures.is_empty() {
             failures_found = true;

From cf85c94ce4dd52213c5df2c00fae398b72565f19 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Wed, 4 Sep 2024 22:32:39 +0100
Subject: [PATCH 08/13] Update: commented out invalid keys from affected themes

---
 runtime/themes/autumn.toml       | 5 +++--
 runtime/themes/emacs.toml        | 3 ++-
 runtime/themes/flatwhite.toml    | 5 +++--
 runtime/themes/kanagawa.toml     | 3 ++-
 runtime/themes/monokai.toml      | 3 ++-
 runtime/themes/monokai_aqua.toml | 7 ++++---
 runtime/themes/zed_onedark.toml  | 3 ++-
 7 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/runtime/themes/autumn.toml b/runtime/themes/autumn.toml
index 7e9b3a7e1ed7..c066e03fbd30 100644
--- a/runtime/themes/autumn.toml
+++ b/runtime/themes/autumn.toml
@@ -68,8 +68,9 @@
 "ui.statusline.select" = { fg = "my_gray7", bg = "my_black", modifiers = ["bold"] }
 "ui.text.focus" = "my_white1"
 "ui.text" = "my_white1"
-"ui.virtual.inlay-hint" = { fg = "my_gray4", bg="my_black", modifiers = ["normal"] }
-"ui.virtual.inlay-hint.parameter" = { fg = "my_gray4", modifiers = ["normal"] }
+# Invalid modifier: "normal". See 'https://github.com/helix-editor/helix/issues/5709'
+# "ui.virtual.inlay-hint" = { fg = "my_gray4", bg="my_black", modifiers = ["normal"] }
+# "ui.virtual.inlay-hint.parameter" = { fg = "my_gray4", modifiers = ["normal"] }
 "ui.virtual.inlay-hint.type" = { fg = "my_gray4", modifiers = ["italic"] }
 "ui.virtual.jump-label" = { fg = "my_yellow2", modifiers = ["bold"] }
 "ui.virtual.ruler" = { bg = "my_gray1" }
diff --git a/runtime/themes/emacs.toml b/runtime/themes/emacs.toml
index c60afe99e338..dfd55e07b304 100644
--- a/runtime/themes/emacs.toml
+++ b/runtime/themes/emacs.toml
@@ -68,7 +68,8 @@
 "ui.menu.selected" = { fg = "dark_red", bg = "light_blue" }
 "ui.selection" = { bg = "lightgoldenrod1" }
 "ui.selection.primary" = { bg = "lightgoldenrod2" }
-"ui.virtual.whitespace" = "highlight"
+# Malformed ANSI: highlight. See 'https://github.com/helix-editor/helix/issues/5709'
+# "ui.virtual.whitespace" = "highlight"
 "ui.virtual.ruler" = { bg = "gray95" }
 "ui.virtual.inlay-hint" = { fg = "gray75" }
 "ui.cursorline.primary" = { bg = "darkseagreen2" }
diff --git a/runtime/themes/flatwhite.toml b/runtime/themes/flatwhite.toml
index cc8f536cbd86..2c4b9de9fc62 100644
--- a/runtime/themes/flatwhite.toml
+++ b/runtime/themes/flatwhite.toml
@@ -61,8 +61,9 @@
 "ui.virtual" = { fg = "base5", bg = "base6" }
 "ui.virtual.whitespace" = { fg = "base5" }
 "ui.virtual.ruler" = { bg = "base6" }
-"ui.virtual.inlay-hint" = { fg = "base4", modifiers = ["normal"] }
-"ui.virtual.inlay-hint.parameter" = { fg = "base3", modifiers = ["normal"] }
+# Invalid modifier: "normal". See 'https://github.com/helix-editor/helix/issues/5709'
+# "ui.virtual.inlay-hint" = { fg = "base4", modifiers = ["normal"] }
+# "ui.virtual.inlay-hint.parameter" = { fg = "base3", modifiers = ["normal"] }
 "ui.virtual.inlay-hint.type" = { fg = "base3", modifiers = ["italic"] }
 
 "ui.linenr" = { bg = "base6" }
diff --git a/runtime/themes/kanagawa.toml b/runtime/themes/kanagawa.toml
index dabece68d1e5..8d5a80eefa58 100644
--- a/runtime/themes/kanagawa.toml
+++ b/runtime/themes/kanagawa.toml
@@ -25,7 +25,8 @@
 "ui.statusline.normal" = { fg = "sumiInk0", bg = "crystalBlue", modifiers = ["bold"] }
 "ui.statusline.insert" = { fg = "sumiInk0", bg = "autumnGreen", modifiers = ["bold"] }
 "ui.statusline.select" = { fg = "sumiInk0", bg = "oniViolet", modifiers = ["bold"] }
-"ui.statusline.separator" = { fg = "", bg = "" }
+# Malformed ANSI: "". See 'https://github.com/helix-editor/helix/issues/5709'
+# "ui.statusline.separator" = { fg = "", bg = "" }
 
 "ui.bufferline" = { fg = "fujiGray", bg = "sumiInk0" }
 "ui.bufferline.active" = { fg = "oldWhite", bg = "sumiInk0" }
diff --git a/runtime/themes/monokai.toml b/runtime/themes/monokai.toml
index b0faac1546ed..0fefdb40c6fe 100644
--- a/runtime/themes/monokai.toml
+++ b/runtime/themes/monokai.toml
@@ -79,7 +79,8 @@
 "ui.statusline" = { fg = "active_text", bg = "#414339" }
 "ui.statusline.inactive" = { fg = "active_text", bg = "#75715e" }
 
-"ui.bufferline" = { fg = "grey2", bg = "bg3" }
+# Malformed ANSI: bg3. See 'https://github.com/helix-editor/helix/issues/5709'
+# "ui.bufferline" = { fg = "grey2", bg = "bg3" }
 "ui.bufferline.active" = { fg = "active_text", bg = "selection", modifiers = [
   "bold",
 ] }
diff --git a/runtime/themes/monokai_aqua.toml b/runtime/themes/monokai_aqua.toml
index 0cb9300d053a..a37d4e3c0b42 100644
--- a/runtime/themes/monokai_aqua.toml
+++ b/runtime/themes/monokai_aqua.toml
@@ -8,9 +8,10 @@ inherits = "monokai"
 
 "type" = { fg = "type", modifiers = ["bold"] }
 
-"ui.statusline.normal" = { fg = "light-black", bg = "cyan" }
-"ui.statusline.insert" = { fg = "light-black", bg = "green" }
-"ui.statusline.select" = { fg = "light-black", bg = "purple" }
+# Malformed ANSI: light-black, purple. See 'https://github.com/helix-editor/helix/issues/5709'
+# "ui.statusline.normal" = { fg = "light-black", bg = "cyan" }
+# "ui.statusline.insert" = { fg = "light-black", bg = "green" }
+# "ui.statusline.select" = { fg = "light-black", bg = "purple" }
 
 "ui.virtual.jump-label" = { fg = "cyan", modifiers = ["bold"] }
 
diff --git a/runtime/themes/zed_onedark.toml b/runtime/themes/zed_onedark.toml
index 74db8f75cd31..160320de1411 100644
--- a/runtime/themes/zed_onedark.toml
+++ b/runtime/themes/zed_onedark.toml
@@ -61,7 +61,8 @@
 "ui.cursor" = { fg = "white", modifiers = ["reversed"] }
 "ui.cursor.primary" = { fg = "white", modifiers = ["reversed"] }
 "ui.cursor.match" = { fg = "blue", modifiers = ["underlined"] }
-"ui.cursor.insert" = { fg = "dark-blue" }
+# Malformed ANSI: dark-blue. See 'https://github.com/helix-editor/helix/issues/5709'
+# "ui.cursor.insert" = { fg = "dark-blue" }
 
 "ui.selection" = { bg = "faint-gray" }
 "ui.selection.primary" = { bg = "#293b5bff" }

From 9071387ad14eaa86e96cb4d34d3ca0dadded1475 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Fri, 6 Sep 2024 16:46:35 +0100
Subject: [PATCH 09/13] Update: correct invalid keys so that valid styles still
 applied

---
 runtime/themes/autumn.toml       | 3 ++-
 runtime/themes/flatwhite.toml    | 2 ++
 runtime/themes/monokai.toml      | 2 +-
 runtime/themes/monokai_aqua.toml | 2 ++
 4 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/runtime/themes/autumn.toml b/runtime/themes/autumn.toml
index c066e03fbd30..d7d9c00bde16 100644
--- a/runtime/themes/autumn.toml
+++ b/runtime/themes/autumn.toml
@@ -69,8 +69,9 @@
 "ui.text.focus" = "my_white1"
 "ui.text" = "my_white1"
 # Invalid modifier: "normal". See 'https://github.com/helix-editor/helix/issues/5709'
-# "ui.virtual.inlay-hint" = { fg = "my_gray4", bg="my_black", modifiers = ["normal"] }
+"ui.virtual.inlay-hint" = { fg = "my_gray4", bg="my_black" } #, modifiers = ["normal"] }
 # "ui.virtual.inlay-hint.parameter" = { fg = "my_gray4", modifiers = ["normal"] }
+"ui.virtual.inlay-hint.parameter" = "my_gray4"
 "ui.virtual.inlay-hint.type" = { fg = "my_gray4", modifiers = ["italic"] }
 "ui.virtual.jump-label" = { fg = "my_yellow2", modifiers = ["bold"] }
 "ui.virtual.ruler" = { bg = "my_gray1" }
diff --git a/runtime/themes/flatwhite.toml b/runtime/themes/flatwhite.toml
index 2c4b9de9fc62..1da203502aa8 100644
--- a/runtime/themes/flatwhite.toml
+++ b/runtime/themes/flatwhite.toml
@@ -64,6 +64,8 @@
 # Invalid modifier: "normal". See 'https://github.com/helix-editor/helix/issues/5709'
 # "ui.virtual.inlay-hint" = { fg = "base4", modifiers = ["normal"] }
 # "ui.virtual.inlay-hint.parameter" = { fg = "base3", modifiers = ["normal"] }
+"ui.virtual.inlay-hint" = "base4"
+"ui.virtual.inlay-hint.parameter" = "base3"
 "ui.virtual.inlay-hint.type" = { fg = "base3", modifiers = ["italic"] }
 
 "ui.linenr" = { bg = "base6" }
diff --git a/runtime/themes/monokai.toml b/runtime/themes/monokai.toml
index 0fefdb40c6fe..22e6d063976e 100644
--- a/runtime/themes/monokai.toml
+++ b/runtime/themes/monokai.toml
@@ -79,7 +79,7 @@
 "ui.statusline" = { fg = "active_text", bg = "#414339" }
 "ui.statusline.inactive" = { fg = "active_text", bg = "#75715e" }
 
-# Malformed ANSI: bg3. See 'https://github.com/helix-editor/helix/issues/5709'
+# Malformed ANSI: grey2, bg3. See 'https://github.com/helix-editor/helix/issues/5709'
 # "ui.bufferline" = { fg = "grey2", bg = "bg3" }
 "ui.bufferline.active" = { fg = "active_text", bg = "selection", modifiers = [
   "bold",
diff --git a/runtime/themes/monokai_aqua.toml b/runtime/themes/monokai_aqua.toml
index a37d4e3c0b42..b818a09e74eb 100644
--- a/runtime/themes/monokai_aqua.toml
+++ b/runtime/themes/monokai_aqua.toml
@@ -10,7 +10,9 @@ inherits = "monokai"
 
 # Malformed ANSI: light-black, purple. See 'https://github.com/helix-editor/helix/issues/5709'
 # "ui.statusline.normal" = { fg = "light-black", bg = "cyan" }
+"ui.statusline.normal" = { bg = "cyan" }
 # "ui.statusline.insert" = { fg = "light-black", bg = "green" }
+"ui.statusline.insert" = { bg = "green" }
 # "ui.statusline.select" = { fg = "light-black", bg = "purple" }
 
 "ui.virtual.jump-label" = { fg = "cyan", modifiers = ["bold"] }

From e5070ade7eea97ecdc2458469ca3a31b3ec8a125 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Fri, 6 Sep 2024 16:57:10 +0100
Subject: [PATCH 10/13] Update: include default and base16_default themes in
 check

---
 xtask/src/theme_check.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/xtask/src/theme_check.rs b/xtask/src/theme_check.rs
index 3edbde5024cc..b2eaf6f98d83 100644
--- a/xtask/src/theme_check.rs
+++ b/xtask/src/theme_check.rs
@@ -3,7 +3,11 @@ use helix_view::theme::Loader;
 use crate::{path, DynError};
 
 pub fn theme_check() -> Result<(), DynError> {
-    let theme_names = Loader::read_names(&path::themes());
+    let theme_names = [
+        vec!["default".to_string(), "base16_default".to_string()],
+        Loader::read_names(&path::themes()),
+    ]
+    .concat();
     let loader = Loader::new(&[path::runtime()]);
     let mut failures_found = false;
 

From 8daf3f02c7d7822c73d043d7fbe7f350b2f104ec Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Sat, 7 Sep 2024 18:17:36 +0100
Subject: [PATCH 11/13] Update: renamed validation_failures to load_errors

---
 helix-term/src/application.rs    | 12 ++++++------
 helix-term/src/commands/typed.rs | 12 ++++++------
 helix-view/src/theme.rs          | 27 +++++++++++++++------------
 xtask/src/theme_check.rs         | 18 +++++++++---------
 4 files changed, 36 insertions(+), 33 deletions(-)

diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index 3173917d8b0c..f7530aaaae72 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -120,9 +120,9 @@ impl Application {
                         log::warn!("failed to load theme `{}` - {}", theme, e);
                         e
                     })
-                    .map(|(theme, validation_failures)| {
-                        for validation_failure in validation_failures {
-                            log::warn!("{validation_failure}");
+                    .map(|(theme, load_errors)| {
+                        for error in load_errors {
+                            log::warn!("{}", error);
                         }
                         theme
                     })
@@ -441,9 +441,9 @@ impl Application {
                         log::warn!("failed to load theme `{}` - {}", theme, e);
                         e
                     })
-                    .map(|(theme, validation_failures)| {
-                        for validation_failure in validation_failures {
-                            log::warn!("{validation_failure}");
+                    .map(|(theme, load_errors)| {
+                        for error in load_errors {
+                            log::warn!("{}", error);
                         }
                         theme
                     })
diff --git a/helix-term/src/commands/typed.rs b/helix-term/src/commands/typed.rs
index 5abd7f69bb21..b075c0c7cb69 100644
--- a/helix-term/src/commands/typed.rs
+++ b/helix-term/src/commands/typed.rs
@@ -879,12 +879,12 @@ fn theme(
                 // Ensures that a preview theme gets cleaned up if the user backspaces until the prompt is empty.
                 cx.editor.unset_theme_preview();
             } else if let Some(theme_name) = args.first() {
-                if let Ok((theme, validation_failures)) = cx.editor.theme_loader.load(theme_name) {
+                if let Ok((theme, load_errors)) = cx.editor.theme_loader.load(theme_name) {
                     if !(true_color || theme.is_16_color()) {
                         bail!("Unsupported theme: theme requires true color support");
                     }
-                    for validation_failure in validation_failures {
-                        log::warn!("{validation_failure}");
+                    for error in load_errors {
+                        log::warn!("{}", error);
                     }
                     cx.editor.set_theme_preview(theme);
                 };
@@ -896,9 +896,9 @@ fn theme(
                     .editor
                     .theme_loader
                     .load(theme_name)
-                    .map(|(theme, validation_failures)| {
-                        for validation_failure in validation_failures {
-                            log::warn!("{validation_failure}");
+                    .map(|(theme, load_errors)| {
+                        for error in load_errors {
+                            log::warn!("{}", error);
                         }
                         theme
                     })
diff --git a/helix-view/src/theme.rs b/helix-view/src/theme.rs
index 6b46c41896f9..781824fe5ee3 100644
--- a/helix-view/src/theme.rs
+++ b/helix-view/src/theme.rs
@@ -61,7 +61,7 @@ impl Loader {
         }
 
         let mut visited_paths = HashSet::new();
-        let (theme, validation_failures) = self
+        let (theme, load_errors) = self
             .load_theme(name, &mut visited_paths)
             .map(Theme::from_toml)?;
 
@@ -69,7 +69,7 @@ impl Loader {
             name: name.into(),
             ..theme
         };
-        Ok((theme, validation_failures))
+        Ok((theme, load_errors))
     }
 
     /// Recursively load a theme, merging with any inherited parent themes.
@@ -223,7 +223,10 @@ pub struct Theme {
 
 impl From<Value> for Theme {
     fn from(value: Value) -> Self {
-        let (theme, _) = Theme::from_toml(value);
+        let (theme, load_errors) = Theme::from_toml(value);
+        for error in load_errors {
+            warn!("{}", error);
+        }
         theme
     }
 }
@@ -234,9 +237,9 @@ impl<'de> Deserialize<'de> for Theme {
         D: Deserializer<'de>,
     {
         let values = Map::<String, Value>::deserialize(deserializer)?;
-        let (theme, validation_failures) = Theme::from_keys(values);
-        for validation_failure in validation_failures {
-            warn!("{}", validation_failure);
+        let (theme, load_errors) = Theme::from_keys(values);
+        for error in load_errors {
+            warn!("{}", error);
         }
         Ok(theme)
     }
@@ -249,14 +252,14 @@ fn build_theme_values(
     let mut scopes = Vec::new();
     let mut highlights = Vec::new();
 
-    let mut validation_failures = Vec::new();
+    let mut load_errors = Vec::new();
 
     // TODO: alert user of parsing failures in editor
     let palette = values
         .remove("palette")
         .map(|value| {
             ThemePalette::try_from(value).unwrap_or_else(|err| {
-                validation_failures.push(err);
+                load_errors.push(err);
                 ThemePalette::default()
             })
         })
@@ -269,7 +272,7 @@ fn build_theme_values(
     for (name, style_value) in values {
         let mut style = Style::default();
         if let Err(err) = palette.parse_style(&mut style, style_value) {
-            validation_failures.push(err);
+            load_errors.push(err);
         }
 
         // these are used both as UI and as highlights
@@ -278,7 +281,7 @@ fn build_theme_values(
         highlights.push(style);
     }
 
-    (styles, scopes, highlights, validation_failures)
+    (styles, scopes, highlights, load_errors)
 }
 
 impl Theme {
@@ -355,7 +358,7 @@ impl Theme {
     }
 
     fn from_keys(toml_keys: Map<String, Value>) -> (Self, Vec<String>) {
-        let (styles, scopes, highlights, validation_failures) = build_theme_values(toml_keys);
+        let (styles, scopes, highlights, load_errors) = build_theme_values(toml_keys);
 
         let theme = Self {
             styles,
@@ -363,7 +366,7 @@ impl Theme {
             highlights,
             ..Default::default()
         };
-        (theme, validation_failures)
+        (theme, load_errors)
     }
 }
 
diff --git a/xtask/src/theme_check.rs b/xtask/src/theme_check.rs
index b2eaf6f98d83..ad90e3fa1e53 100644
--- a/xtask/src/theme_check.rs
+++ b/xtask/src/theme_check.rs
@@ -9,22 +9,22 @@ pub fn theme_check() -> Result<(), DynError> {
     ]
     .concat();
     let loader = Loader::new(&[path::runtime()]);
-    let mut failures_found = false;
+    let mut errors_present = false;
 
     for name in theme_names {
-        let (_, validation_failures) = loader.load(&name).unwrap();
+        let (_, load_errors) = loader.load(&name).unwrap();
 
-        if !validation_failures.is_empty() {
-            failures_found = true;
-            println!("Theme '{name}' loaded with warnings:");
-            for failure in validation_failures {
-                println!("\t* {failure}");
+        if !load_errors.is_empty() {
+            errors_present = true;
+            println!("Theme '{name}' loaded with errors:");
+            for error in load_errors {
+                println!("\t* {}", error);
             }
         }
     }
 
-    match failures_found {
-        true => Err("Validation failures found in bundled themes".into()),
+    match errors_present {
+        true => Err("Errors found when loading bundled themes".into()),
         false => {
             println!("Theme check successful!");
             Ok(())

From 664bfa2f095d1a37b437f8fee6de88ca616e1792 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Mon, 23 Sep 2024 20:19:09 +0100
Subject: [PATCH 12/13] Update: introduce load_with_warnings helper function
 and centralise logging of theme warnings

---
 helix-term/src/application.rs    | 12 -------
 helix-term/src/commands/typed.rs | 11 +-----
 helix-view/src/theme.rs          | 58 +++++++++++++++++---------------
 xtask/src/theme_check.rs         |  8 ++---
 4 files changed, 36 insertions(+), 53 deletions(-)

diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index f7530aaaae72..bd6b5a870e3d 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -120,12 +120,6 @@ impl Application {
                         log::warn!("failed to load theme `{}` - {}", theme, e);
                         e
                     })
-                    .map(|(theme, load_errors)| {
-                        for error in load_errors {
-                            log::warn!("{}", error);
-                        }
-                        theme
-                    })
                     .ok()
                     .filter(|theme| (true_color || theme.is_16_color()))
             })
@@ -441,12 +435,6 @@ impl Application {
                         log::warn!("failed to load theme `{}` - {}", theme, e);
                         e
                     })
-                    .map(|(theme, load_errors)| {
-                        for error in load_errors {
-                            log::warn!("{}", error);
-                        }
-                        theme
-                    })
                     .ok()
                     .filter(|theme| (true_color || theme.is_16_color()))
             })
diff --git a/helix-term/src/commands/typed.rs b/helix-term/src/commands/typed.rs
index b075c0c7cb69..7ad0369fc1bd 100644
--- a/helix-term/src/commands/typed.rs
+++ b/helix-term/src/commands/typed.rs
@@ -879,13 +879,10 @@ fn theme(
                 // Ensures that a preview theme gets cleaned up if the user backspaces until the prompt is empty.
                 cx.editor.unset_theme_preview();
             } else if let Some(theme_name) = args.first() {
-                if let Ok((theme, load_errors)) = cx.editor.theme_loader.load(theme_name) {
+                if let Ok(theme) = cx.editor.theme_loader.load(theme_name) {
                     if !(true_color || theme.is_16_color()) {
                         bail!("Unsupported theme: theme requires true color support");
                     }
-                    for error in load_errors {
-                        log::warn!("{}", error);
-                    }
                     cx.editor.set_theme_preview(theme);
                 };
             };
@@ -896,12 +893,6 @@ fn theme(
                     .editor
                     .theme_loader
                     .load(theme_name)
-                    .map(|(theme, load_errors)| {
-                        for error in load_errors {
-                            log::warn!("{}", error);
-                        }
-                        theme
-                    })
                     .map_err(|err| anyhow::anyhow!("Could not load theme: {}", err))?;
                 if !(true_color || theme.is_16_color()) {
                     bail!("Unsupported theme: theme requires true color support");
diff --git a/helix-view/src/theme.rs b/helix-view/src/theme.rs
index 781824fe5ee3..b781878ea4ff 100644
--- a/helix-view/src/theme.rs
+++ b/helix-view/src/theme.rs
@@ -52,7 +52,18 @@ impl Loader {
     }
 
     /// Loads a theme searching directories in priority order.
-    pub fn load(&self, name: &str) -> Result<(Theme, Vec<String>)> {
+    pub fn load(&self, name: &str) -> Result<Theme> {
+        let (theme, warnings) = self.load_with_warnings(name)?;
+
+        for warning in warnings {
+            warn!("Theme '{}': {}", name, warning);
+        }
+
+        Ok(theme)
+    }
+
+    /// Loads a theme searching directories in priority order, returning any warnings
+    pub fn load_with_warnings(&self, name: &str) -> Result<(Theme, Vec<String>)> {
         if name == "default" {
             return Ok((self.default(), Vec::new()));
         }
@@ -90,10 +101,7 @@ impl Loader {
 
         let theme_toml = if let Some(parent_theme_name) = inherits {
             let parent_theme_name = parent_theme_name.as_str().ok_or_else(|| {
-                anyhow!(
-                    "Theme: expected 'inherits' to be a string: {}",
-                    parent_theme_name
-                )
+                anyhow!("Expected 'inherits' to be a string: {}", parent_theme_name)
             })?;
 
             let parent_theme_toml = match parent_theme_name {
@@ -184,9 +192,9 @@ impl Loader {
             })
             .ok_or_else(|| {
                 if cycle_found {
-                    anyhow!("Theme: cycle found in inheriting: {}", name)
+                    anyhow!("Cycle found in inheriting: {}", name)
                 } else {
-                    anyhow!("Theme: file not found for: {}", name)
+                    anyhow!("File not found for: {}", name)
                 }
             })
     }
@@ -237,9 +245,9 @@ impl<'de> Deserialize<'de> for Theme {
         D: Deserializer<'de>,
     {
         let values = Map::<String, Value>::deserialize(deserializer)?;
-        let (theme, load_errors) = Theme::from_keys(values);
-        for error in load_errors {
-            warn!("{}", error);
+        let (theme, warnings) = Theme::from_keys(values);
+        for warning in warnings {
+            warn!("{}", warning);
         }
         Ok(theme)
     }
@@ -252,14 +260,14 @@ fn build_theme_values(
     let mut scopes = Vec::new();
     let mut highlights = Vec::new();
 
-    let mut load_errors = Vec::new();
+    let mut warnings = Vec::new();
 
     // TODO: alert user of parsing failures in editor
     let palette = values
         .remove("palette")
         .map(|value| {
             ThemePalette::try_from(value).unwrap_or_else(|err| {
-                load_errors.push(err);
+                warnings.push(err);
                 ThemePalette::default()
             })
         })
@@ -272,7 +280,7 @@ fn build_theme_values(
     for (name, style_value) in values {
         let mut style = Style::default();
         if let Err(err) = palette.parse_style(&mut style, style_value) {
-            load_errors.push(err);
+            warnings.push(err);
         }
 
         // these are used both as UI and as highlights
@@ -281,7 +289,7 @@ fn build_theme_values(
         highlights.push(style);
     }
 
-    (styles, scopes, highlights, load_errors)
+    (styles, scopes, highlights, warnings)
 }
 
 impl Theme {
@@ -422,7 +430,7 @@ impl ThemePalette {
         if let Ok(index) = s.parse::<u8>() {
             return Ok(Color::Indexed(index));
         }
-        Err(format!("Theme: malformed ANSI: {}", s))
+        Err(format!("Malformed ANSI: {}", s))
     }
 
     fn hex_string_to_rgb(s: &str) -> Result<Color, String> {
@@ -436,13 +444,13 @@ impl ThemePalette {
             }
         }
 
-        Err(format!("Theme: malformed hexcode: {}", s))
+        Err(format!("Malformed hexcode: {}", s))
     }
 
     fn parse_value_as_str(value: &Value) -> Result<&str, String> {
         value
             .as_str()
-            .ok_or(format!("Theme: unrecognized value: {}", value))
+            .ok_or(format!("Unrecognized value: {}", value))
     }
 
     pub fn parse_color(&self, value: Value) -> Result<Color, String> {
@@ -459,14 +467,14 @@ impl ThemePalette {
         value
             .as_str()
             .and_then(|s| s.parse().ok())
-            .ok_or(format!("Theme: invalid modifier: {}", value))
+            .ok_or(format!("Invalid modifier: {}", value))
     }
 
     pub fn parse_underline_style(value: &Value) -> Result<UnderlineStyle, String> {
         value
             .as_str()
             .and_then(|s| s.parse().ok())
-            .ok_or(format!("Theme: invalid underline style: {}", value))
+            .ok_or(format!("Invalid underline style: {}", value))
     }
 
     pub fn parse_style(&self, style: &mut Style, value: Value) -> Result<(), String> {
@@ -476,9 +484,7 @@ impl ThemePalette {
                     "fg" => *style = style.fg(self.parse_color(value)?),
                     "bg" => *style = style.bg(self.parse_color(value)?),
                     "underline" => {
-                        let table = value
-                            .as_table_mut()
-                            .ok_or("Theme: underline must be table")?;
+                        let table = value.as_table_mut().ok_or("Underline must be table")?;
                         if let Some(value) = table.remove("color") {
                             *style = style.underline_color(self.parse_color(value)?);
                         }
@@ -487,13 +493,11 @@ impl ThemePalette {
                         }
 
                         if let Some(attr) = table.keys().next() {
-                            return Err(format!("Theme: invalid underline attribute: {attr}"));
+                            return Err(format!("Invalid underline attribute: {attr}"));
                         }
                     }
                     "modifiers" => {
-                        let modifiers = value
-                            .as_array()
-                            .ok_or("Theme: modifiers should be an array")?;
+                        let modifiers = value.as_array().ok_or("Modifiers should be an array")?;
 
                         for modifier in modifiers {
                             if modifier
@@ -506,7 +510,7 @@ impl ThemePalette {
                             }
                         }
                     }
-                    _ => return Err(format!("Theme: invalid style attribute: {}", name)),
+                    _ => return Err(format!("Invalid style attribute: {}", name)),
                 }
             }
         } else {
diff --git a/xtask/src/theme_check.rs b/xtask/src/theme_check.rs
index ad90e3fa1e53..a2719ede821a 100644
--- a/xtask/src/theme_check.rs
+++ b/xtask/src/theme_check.rs
@@ -12,13 +12,13 @@ pub fn theme_check() -> Result<(), DynError> {
     let mut errors_present = false;
 
     for name in theme_names {
-        let (_, load_errors) = loader.load(&name).unwrap();
+        let (_, warnings) = loader.load_with_warnings(&name).unwrap();
 
-        if !load_errors.is_empty() {
+        if !warnings.is_empty() {
             errors_present = true;
             println!("Theme '{name}' loaded with errors:");
-            for error in load_errors {
-                println!("\t* {}", error);
+            for warning in warnings {
+                println!("\t* {}", warning);
             }
         }
     }

From 010039fc397976bc393b5519e959cc518022f809 Mon Sep 17 00:00:00 2001
From: Tim <timothy_may@hotmail.co.uk>
Date: Mon, 23 Sep 2024 20:23:15 +0100
Subject: [PATCH 13/13] Update: use consistent naming throughout

---
 helix-view/src/theme.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/helix-view/src/theme.rs b/helix-view/src/theme.rs
index b781878ea4ff..9dc326444b9b 100644
--- a/helix-view/src/theme.rs
+++ b/helix-view/src/theme.rs
@@ -72,7 +72,7 @@ impl Loader {
         }
 
         let mut visited_paths = HashSet::new();
-        let (theme, load_errors) = self
+        let (theme, warnings) = self
             .load_theme(name, &mut visited_paths)
             .map(Theme::from_toml)?;
 
@@ -80,7 +80,7 @@ impl Loader {
             name: name.into(),
             ..theme
         };
-        Ok((theme, load_errors))
+        Ok((theme, warnings))
     }
 
     /// Recursively load a theme, merging with any inherited parent themes.
@@ -231,9 +231,9 @@ pub struct Theme {
 
 impl From<Value> for Theme {
     fn from(value: Value) -> Self {
-        let (theme, load_errors) = Theme::from_toml(value);
-        for error in load_errors {
-            warn!("{}", error);
+        let (theme, warnings) = Theme::from_toml(value);
+        for warning in warnings {
+            warn!("{}", warning);
         }
         theme
     }