derive: better use of spans and file information in error messages

rinja_derive/Cargo.toml

@@ -26,6 +26,7 @@ with-warp = []
 
 [dependencies]
 parser = { package = "rinja_parser", version = "0.2.0", path = "../rinja_parser" }
+annotate-snippets = "0.11.4"
 basic-toml = { version = "0.1.1", optional = true }
 memchr = "2"
 mime = "0.3"

rinja_derive/src/config.rs

@@ -198,6 +198,7 @@ impl Config {
         &self,
         path: &str,
         start_at: Option<&Path>,
+        file_info: Option<FileInfo<'_>>,
     ) -> Result<Arc<Path>, CompileError> {
         if let Some(root) = start_at {
             let relative = root.with_file_name(path);
@@ -213,10 +214,13 @@ impl Config {
             }
         }
 
-        Err(CompileError::no_file_info(format!(
-            "template {:?} not found in directories {:?}",
-            path, self.dirs
-        )))
+        Err(CompileError::new(
+            format!(
+                "template {:?} not found in directories {:?}",
+                path, self.dirs
+            ),
+            file_info,
+        ))
     }
 }
 
@@ -319,13 +323,15 @@ impl<'a> TryInto<Syntax<'a>> for RawSyntax<'a> {
             syntax.comment_end,
         ] {
             if s.len() < 2 {
-                return Err(CompileError::no_file_info(format!(
-                    "delimiters must be at least two characters long: {s:?}"
-                )));
+                return Err(CompileError::no_file_info(
+                    format!("delimiters must be at least two characters long: {s:?}"),
+                    None,
+                ));
             } else if s.chars().any(|c| c.is_whitespace()) {
-                return Err(CompileError::no_file_info(format!(
-                    "delimiters may not contain white spaces: {s:?}"
-                )));
+                return Err(CompileError::no_file_info(
+                    format!("delimiters may not contain white spaces: {s:?}"),
+                    None,
+                ));
             }
         }
 
@@ -335,9 +341,12 @@ impl<'a> TryInto<Syntax<'a>> for RawSyntax<'a> {
             (syntax.expr_start, syntax.comment_start),
         ] {
             if s1.starts_with(s2) || s2.starts_with(s1) {
-                return Err(CompileError::no_file_info(format!(
-                    "a delimiter may not be the prefix of another delimiter: {s1:?} vs {s2:?}",
-                )));
+                return Err(CompileError::no_file_info(
+                    format!(
+                        "a delimiter may not be the prefix of another delimiter: {s1:?} vs {s2:?}",
+                    ),
+                    None,
+                ));
             }
         }
 
@@ -358,13 +367,16 @@ impl RawConfig<'_> {
     #[cfg(feature = "config")]
     fn from_toml_str(s: &str) -> Result<RawConfig<'_>, CompileError> {
         basic_toml::from_str(s).map_err(|e| {
-            CompileError::no_file_info(format!("invalid TOML in {CONFIG_FILE_NAME}: {e}"))
+            CompileError::no_file_info(format!("invalid TOML in {CONFIG_FILE_NAME}: {e}"), None)
         })
     }
 
     #[cfg(not(feature = "config"))]
     fn from_toml_str(_: &str) -> Result<RawConfig<'_>, CompileError> {
-        Err(CompileError::no_file_info("TOML support not available"))
+        Err(CompileError::no_file_info(
+            "TOML support not available",
+            None,
+        ))
     }
 }
 
@@ -428,13 +440,13 @@ pub(crate) fn read_config_file(config_path: Option<&str>) -> Result<String, Comp
 
     if filename.exists() {
         fs::read_to_string(&filename).map_err(|_| {
-            CompileError::no_file_info(format!("unable to read {:?}", filename.to_str().unwrap()))
+            CompileError::no_file_info(format!("unable to read {}", filename.display()), None)
         })
     } else if config_path.is_some() {
-        Err(CompileError::no_file_info(format!(
-            "`{}` does not exist",
-            root.display()
-        )))
+        Err(CompileError::no_file_info(
+            format!("`{}` does not exist", root.display()),
+            None,
+        ))
     } else {
         Ok("".to_string())
     }
@@ -489,32 +501,36 @@ mod tests {
     #[test]
     fn find_absolute() {
         let config = Config::new("", None, None).unwrap();
-        let root = config.find_template("a.html", None).unwrap();
-        let path = config.find_template("sub/b.html", Some(&root)).unwrap();
+        let root = config.find_template("a.html", None, None).unwrap();
+        let path = config
+            .find_template("sub/b.html", Some(&root), None)
+            .unwrap();
         assert_eq_rooted(&path, "sub/b.html");
     }
 
     #[test]
     #[should_panic]
     fn find_relative_nonexistent() {
         let config = Config::new("", None, None).unwrap();
-        let root = config.find_template("a.html", None).unwrap();
-        config.find_template("c.html", Some(&root)).unwrap();
+        let root = config.find_template("a.html", None, None).unwrap();
+        config.find_template("c.html", Some(&root), None).unwrap();
     }
 
     #[test]
     fn find_relative() {
         let config = Config::new("", None, None).unwrap();
-        let root = config.find_template("sub/b.html", None).unwrap();
-        let path = config.find_template("c.html", Some(&root)).unwrap();
+        let root = config.find_template("sub/b.html", None, None).unwrap();
+        let path = config.find_template("c.html", Some(&root), None).unwrap();
         assert_eq_rooted(&path, "sub/c.html");
     }
 
     #[test]
     fn find_relative_sub() {
         let config = Config::new("", None, None).unwrap();
-        let root = config.find_template("sub/b.html", None).unwrap();
-        let path = config.find_template("sub1/d.html", Some(&root)).unwrap();
+        let root = config.find_template("sub/b.html", None, None).unwrap();
+        let path = config
+            .find_template("sub1/d.html", Some(&root), None)
+            .unwrap();
         assert_eq_rooted(&path, "sub/sub1/d.html");
     }
 

rinja_derive/src/generator.rs

@@ -16,7 +16,7 @@ use crate::config::WhitespaceHandling;
 use crate::heritage::{Context, Heritage};
 use crate::html::write_escaped_str;
 use crate::input::{Source, TemplateInput};
-use crate::{CompileError, MsgValidEscapers, CRATE};
+use crate::{CompileError, FileInfo, MsgValidEscapers, CRATE};
 
 #[derive(Clone, Copy, PartialEq, Debug)]
 enum EvaluatedResult {
@@ -78,7 +78,13 @@ impl<'a> Generator<'a> {
     pub(crate) fn build(mut self, ctx: &Context<'a>) -> Result<String, CompileError> {
         let mut buf = Buffer::new();
 
-        self.impl_template(ctx, &mut buf)?;
+        if let Err(mut err) = self.impl_template(ctx, &mut buf) {
+            if err.span.is_none() {
+                err.span = self.input.source_span;
+            }
+            return Err(err);
+        }
+
         self.impl_display(&mut buf);
 
         #[cfg(feature = "with-actix-web")]
@@ -907,14 +913,15 @@ impl<'a> Generator<'a> {
         &mut self,
         ctx: &Context<'a>,
         buf: &mut Buffer,
-        i: &'a Include<'_>,
+        i: &'a WithSpan<'_, Include<'_>>,
     ) -> Result<usize, CompileError> {
         self.flush_ws(i.ws);
         self.write_buf_writable(ctx, buf)?;
+        let file_info = ctx.path.map(|path| FileInfo::of(i, path, ctx.parsed));
         let path = self
             .input
             .config
-            .find_template(i.path, Some(&self.input.path))?;
+            .find_template(i.path, Some(&self.input.path), file_info)?;
 
         // We clone the context of the child in order to preserve their macros and imports.
         // But also add all the imports and macros from this template that don't override the

rinja_derive/src/heritage.rs

@@ -44,8 +44,8 @@ pub(crate) struct Context<'a> {
     pub(crate) blocks: HashMap<&'a str, &'a BlockDef<'a>>,
     pub(crate) macros: HashMap<&'a str, &'a Macro<'a>>,
     pub(crate) imports: HashMap<&'a str, Arc<Path>>,
-    path: Option<&'a Path>,
-    parsed: &'a Parsed,
+    pub(crate) path: Option<&'a Path>,
+    pub(crate) parsed: &'a Parsed,
 }
 
 impl Context<'_> {
@@ -84,15 +84,23 @@ impl Context<'_> {
                                 Some(FileInfo::of(e, path, parsed)),
                             ));
                         }
-                        extends = Some(config.find_template(e.path, Some(path))?);
+                        extends = Some(config.find_template(
+                            e.path,
+                            Some(path),
+                            Some(FileInfo::of(e, path, parsed)),
+                        )?);
                     }
                     Node::Macro(m) => {
                         ensure_top(top, m, path, parsed, "macro")?;
                         macros.insert(m.name, &**m);
                     }
                     Node::Import(import) => {
                         ensure_top(top, import, path, parsed, "import")?;
-                        let path = config.find_template(import.path, Some(path))?;
+                        let path = config.find_template(
+                            import.path,
+                            Some(path),
+                            Some(FileInfo::of(import, path, parsed)),
+                        )?;
                         imports.insert(import.scope, path);
                     }
                     Node::BlockDef(b) => {