fix: more-or-less readable errors + syntax check on sassy macro

sabry_intrnl/src/compiler/mod.rs

@@ -1,4 +1,11 @@
-use lightningcss::{printer::PrinterOptions, stylesheet::MinifyOptions, targets::Targets};
+use std::fmt::Debug;
+
+use lightningcss::{
+    error::{MinifyErrorKind, PrinterErrorKind},
+    printer::PrinterOptions,
+    stylesheet::MinifyOptions,
+    targets::Targets,
+};
 
 use crate::config::SabryConfig;
 
@@ -28,7 +35,12 @@ impl CompilerAdapter {
                 lightningcss::stylesheet::ParserOptions::default(),
             ) {
                 Ok(s) => s,
-                Err(_) => return Err(SabryCompilerError::Lightningcss()),
+                Err(e) => {
+                    return Err(SabryCompilerError::LightParse {
+                        kind: e.kind.to_string(),
+                        loc: e.loc,
+                    })
+                }
             };
 
             let targets = Targets {
@@ -47,16 +59,14 @@ impl CompilerAdapter {
                 ..Default::default()
             };
 
-            if lightsheet.minify(minify_options).is_err() {
-                return Err(SabryCompilerError::Lightningcss());
-            }
+            lightsheet.minify(minify_options)?;
 
             css = match lightsheet.to_css(printer_options) {
                 Ok(c) => {
                     drop(lightsheet);
                     c.code
                 }
-                Err(_) => return Err(SabryCompilerError::Lightningcss()),
+                Err(e) => return Err(SabryCompilerError::LightPrint(e)),
             };
         }
 
@@ -78,12 +88,45 @@ impl From<&SabryConfig> for grass::Options<'_> {
     }
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(thiserror::Error)]
 pub enum SabryCompilerError {
     #[error("Could not compile into CSS with grass")]
     GrassCompile(#[from] Box<grass::Error>),
-    #[error("Could not parse compiled CSS with lightningcss")]
-    Lightningcss(),
+    #[error("Could not print compiled CSS with lightningcss")]
+    LightPrint(#[from] lightningcss::error::Error<PrinterErrorKind>),
+    #[error("Could not minify CSS with lightningcss")]
+    LightMinify(#[from] lightningcss::error::Error<MinifyErrorKind>),
+    #[error("Could not parse CSS with lightningcss")]
+    LightParse {
+        kind: String,
+        loc: Option<lightningcss::error::ErrorLocation>,
+    },
+}
+
+impl Debug for SabryCompilerError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let explain = match self {
+            Self::LightPrint(e) => format!(
+                "{} at {:?}",
+                e.kind,
+                e.loc.clone()
+                    .map(|l| format!("file {}, line {}, col {}", l.filename, l.line, l.column))
+            ),
+            Self::GrassCompile(err) => format!("{err}"),
+            Self::LightMinify(e) => format!(
+                "{} at {:?}",
+                e.kind,
+                e.loc.clone()
+                    .map(|l| format!("file {}, line {}, col {}", l.filename, l.line, l.column))
+            ),
+            Self::LightParse { kind, loc } => format!(
+                "{kind} at {:?}",
+                loc.clone().map(|l| format!("file {}, line {}, col {}", l.filename, l.line, l.column))
+            ),
+        };
+
+        write!(f, "{explain}")
+    }
 }
 
 /// Unification wrapper over all the Syntax enums

sabry_intrnl/src/scoper/mod.rs

@@ -1,3 +1,5 @@
+use std::fmt::Debug;
+
 use cfg_if::cfg_if;
 use hash::ScopeHash;
 use raffia::Spanned;
@@ -7,15 +9,19 @@ use crate::{config::SabryHashConfig, syntax::StylesheetAdapter};
 
 pub mod hash;
 
-#[derive(Debug, thiserror::Error)]
+#[derive(thiserror::Error)]
 pub enum ScopeError {
     #[error("Raffia reports parse error")]
-    Raffia(raffia::error::ErrorKind),
+    Raffia(raffia::error::ErrorKind, String),
 }
 
-impl From<raffia::error::Error> for ScopeError {
-    fn from(value: raffia::error::Error) -> Self {
-        Self::Raffia(value.kind)
+impl Debug for ScopeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let a = match self {
+            Self::Raffia(kind, source) => format!("{kind}: at {source}")
+        };
+
+        write!(f, "{a}")
     }
 }
 
@@ -33,8 +39,16 @@ impl<'s> ArbitraryScope<'s> {
         name: syn::Ident,
         source: &'s str,
     ) -> Result<Self, ScopeError> {
+        let adapter = match StylesheetAdapter::new(source, syntax) {
+            Ok(a) => a,
+            Err(e) => {
+                let source = &source[e.span.start..e.span.end];
+                return Err(ScopeError::Raffia(e.kind, source.to_string()))
+            }
+        };
+
         Ok(Self {
-            adapter: StylesheetAdapter::new(source, syntax)?,
+            adapter,
             name,
         })
     }