Add file to error messages

src/assignment_resolver.rs

@@ -42,6 +42,7 @@ impl<'src: 'run, 'run> AssignmentResolver<'src, 'run> {
         column: 0,
         length: 0,
         kind: TokenKind::Unspecified,
+        path: "".as_ref(),
       };
       return Err(CompileError::new(token, Internal { message }));
     }

src/color.rs

@@ -60,6 +60,10 @@ impl Color {
     self.redirect(Stream::Stdout)
   }
 
+  pub(crate) fn context(self) -> Self {
+    self.restyle(Style::new().fg(Blue).bold())
+  }
+
   pub(crate) fn doc(self) -> Self {
     self.restyle(Style::new().fg(Blue))
   }

src/compiler.rs

@@ -15,8 +15,8 @@ impl Compiler {
     paths.push(root.into());
 
     while let Some(current) = paths.pop() {
-      let src = loader.load(&current)?;
-      let tokens = Lexer::lex(src)?;
+      let (relative, src) = loader.load(root, &current)?;
+      let tokens = Lexer::lex(relative, src)?;
       let mut ast = Parser::parse(&tokens)?;
 
       srcs.insert(current.clone(), src);
@@ -56,9 +56,9 @@ impl Compiler {
 
   #[cfg(test)]
   pub(crate) fn test_compile(src: &str) -> CompileResult<Justfile> {
-    let tokens = Lexer::lex(src)?;
+    let tokens = Lexer::test_lex(src)?;
     let ast = Parser::parse(&tokens)?;
-    let root = PathBuf::from("<ROOT>");
+    let root = PathBuf::from("justfile");
     let mut asts: HashMap<PathBuf, Ast> = HashMap::new();
     asts.insert(root.clone(), ast);
     Analyzer::analyze(&asts, &root)

src/lexer.rs

@@ -9,38 +9,45 @@ use {super::*, CompileErrorKind::*, TokenKind::*};
 /// slight against regular expressions, the lexer was just idiosyncratically
 /// bad.
 pub(crate) struct Lexer<'src> {
-  /// Source text
-  src: &'src str,
   /// Char iterator
   chars: Chars<'src>,
-  /// Tokens
-  tokens: Vec<Token<'src>>,
-  /// Current token start
-  token_start: Position,
-  /// Current token end
-  token_end: Position,
-  /// Next character to be lexed
-  next: Option<char>,
-  /// Next indent will start a recipe body
-  recipe_body_pending: bool,
-  /// Inside recipe body
-  recipe_body: bool,
   /// Indentation stack
   indentation: Vec<&'src str>,
   /// Interpolation token start stack
   interpolation_stack: Vec<Token<'src>>,
+  /// Next character to be lexed
+  next: Option<char>,
   /// Current open delimiters
   open_delimiters: Vec<(Delimiter, usize)>,
+  /// Path to source file
+  path: &'src Path,
+  /// Inside recipe body
+  recipe_body: bool,
+  /// Next indent will start a recipe body
+  recipe_body_pending: bool,
+  /// Source text
+  src: &'src str,
+  /// Tokens
+  tokens: Vec<Token<'src>>,
+  /// Current token end
+  token_end: Position,
+  /// Current token start
+  token_start: Position,
 }
 
 impl<'src> Lexer<'src> {
-  /// Lex `text`
-  pub(crate) fn lex(src: &'src str) -> CompileResult<Vec<Token<'src>>> {
-    Lexer::new(src).tokenize()
+  /// Lex `src`
+  pub(crate) fn lex(path: &'src Path, src: &'src str) -> CompileResult<'src, Vec<Token<'src>>> {
+    Lexer::new(path, src).tokenize()
+  }
+
+  #[cfg(test)]
+  pub(crate) fn test_lex(src: &'src str) -> CompileResult<'src, Vec<Token<'src>>> {
+    Lexer::new("justfile".as_ref(), src).tokenize()
   }
 
-  /// Create a new Lexer to lex `text`
-  fn new(src: &'src str) -> Lexer<'src> {
+  /// Create a new Lexer to lex `src`
+  fn new(path: &'src Path, src: &'src str) -> Lexer<'src> {
     let mut chars = src.chars();
     let next = chars.next();
 
@@ -62,6 +69,7 @@ impl<'src> Lexer<'src> {
       chars,
       next,
       src,
+      path,
     }
   }
 
@@ -189,6 +197,7 @@ impl<'src> Lexer<'src> {
       src: self.src,
       length: self.token_end.offset - self.token_start.offset,
       kind,
+      path: self.path,
     });
 
     // Set `token_start` to point after the lexed token
@@ -205,6 +214,7 @@ impl<'src> Lexer<'src> {
       column: self.token_end.column,
       length: 0,
       kind: Unspecified,
+      path: self.path,
     };
     CompileError::new(
       token,
@@ -240,6 +250,7 @@ impl<'src> Lexer<'src> {
       line: self.token_start.line,
       column: self.token_start.column,
       length,
+      path: self.path,
     };
 
     CompileError::new(token, kind)
@@ -920,7 +931,7 @@ mod tests {
       text.to_owned()
     };
 
-    let have = Lexer::lex(&text).unwrap();
+    let have = Lexer::test_lex(&text).unwrap();
 
     let have_kinds = have
       .iter()
@@ -1028,7 +1039,7 @@ mod tests {
     length: usize,
     kind: CompileErrorKind,
   ) {
-    match Lexer::lex(src) {
+    match Lexer::test_lex(src) {
       Ok(_) => panic!("Lexing succeeded but expected"),
       Err(have) => {
         let want = CompileError {
@@ -1039,6 +1050,7 @@ mod tests {
             line,
             column,
             length,
+            path: "justfile".as_ref(),
           },
           kind: Box::new(kind),
         };
@@ -2321,7 +2333,9 @@ mod tests {
 
   #[test]
   fn presume_error() {
-    let compile_error = Lexer::new("!").presume('-').unwrap_err();
+    let compile_error = Lexer::new("justfile".as_ref(), "!")
+      .presume('-')
+      .unwrap_err();
     assert_matches!(
       compile_error.token,
       Token {
@@ -2331,6 +2345,7 @@ mod tests {
         length: 0,
         src: "!",
         kind: Unspecified,
+        path: _,
       }
     );
     assert_matches!(&*compile_error.kind,
@@ -2342,9 +2357,12 @@ mod tests {
       Error::Compile { compile_error }
         .color_display(Color::never())
         .to_string(),
-      "error: Internal error, this may indicate a bug in just: \
-      Lexer presumed character `-`\nconsider filing an issue: \
-      https://github.com/casey/just/issues/new\n  |\n1 | !\n  | ^"
+      "error: Internal error, this may indicate a bug in just: Lexer presumed character `-`
+consider filing an issue: https://github.com/casey/just/issues/new
+ --> justfile:1:1
+  |
+1 | !
+  | ^"
     );
   }
 }

src/loader.rs

@@ -1,22 +1,34 @@
 use super::*;
 
 pub(crate) struct Loader {
-  arena: Arena<String>,
+  srcs: Arena<String>,
+  paths: Arena<PathBuf>,
 }
 
 impl Loader {
   pub(crate) fn new() -> Self {
     Loader {
-      arena: Arena::new(),
+      srcs: Arena::new(),
+      paths: Arena::new(),
     }
   }
 
-  pub(crate) fn load<'src>(&'src self, path: &Path) -> RunResult<&'src str> {
+  pub(crate) fn load<'src>(
+    &'src self,
+    root: &Path,
+    path: &Path,
+  ) -> RunResult<(&'src Path, &'src str)> {
     let src = fs::read_to_string(path).map_err(|io_error| Error::Load {
       path: path.to_owned(),
       io_error,
     })?;
 
-    Ok(self.arena.alloc(src))
+    let relative = if let Ok(path) = path.strip_prefix(root.parent().unwrap()) {
+      path
+    } else {
+      path
+    };
+
+    Ok((self.paths.alloc(relative.into()), self.srcs.alloc(src)))
   }
 }

src/name.rs

@@ -4,10 +4,11 @@ use super::*;
 /// it its own type for clarity.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
 pub(crate) struct Name<'src> {
-  pub(crate) offset: usize,
+  pub(crate) column: usize,
   pub(crate) length: usize,
   pub(crate) line: usize,
-  pub(crate) column: usize,
+  pub(crate) offset: usize,
+  pub(crate) path: &'src Path,
   pub(crate) src: &'src str,
 }
 
@@ -20,22 +21,24 @@ impl<'src> Name<'src> {
   /// Turn this name back into a token
   pub(crate) fn token(&self) -> Token<'src> {
     Token {
+      column: self.column,
       kind: TokenKind::Identifier,
-      offset: self.offset,
       length: self.length,
       line: self.line,
-      column: self.column,
+      offset: self.offset,
+      path: self.path,
       src: self.src,
     }
   }
 
   pub(crate) fn from_identifier(token: Token<'src>) -> Name {
     assert_eq!(token.kind, TokenKind::Identifier);
     Name {
-      offset: token.offset,
+      column: token.column,
       length: token.length,
       line: token.line,
-      column: token.column,
+      offset: token.offset,
+      path: token.path,
       src: token.src,
     }
   }

src/parser.rs

@@ -927,7 +927,7 @@ mod tests {
 
   fn test(text: &str, want: Tree) {
     let unindented = unindent(text);
-    let tokens = Lexer::lex(&unindented).expect("lexing failed");
+    let tokens = Lexer::test_lex(&unindented).expect("lexing failed");
     let justfile = Parser::parse(&tokens).expect("parsing failed");
     let have = justfile.tree();
     if have != want {
@@ -964,7 +964,7 @@ mod tests {
     length: usize,
     kind: CompileErrorKind,
   ) {
-    let tokens = Lexer::lex(src).expect("Lexing failed in parse test...");
+    let tokens = Lexer::test_lex(src).expect("Lexing failed in parse test...");
 
     match Parser::parse(&tokens) {
       Ok(_) => panic!("Parsing unexpectedly succeeded"),
@@ -977,6 +977,7 @@ mod tests {
             line,
             column,
             length,
+            path: "justfile".as_ref(),
           },
           kind: Box::new(kind),
         };

src/testing.rs

@@ -57,11 +57,11 @@ pub(crate) fn analysis_error(
   length: usize,
   kind: CompileErrorKind,
 ) {
-  let tokens = Lexer::lex(src).expect("Lexing failed in parse test...");
+  let tokens = Lexer::test_lex(src).expect("Lexing failed in parse test...");
 
   let ast = Parser::parse(&tokens).expect("Parsing failed in analysis test...");
 
-  let root = PathBuf::from("<ROOT>");
+  let root = PathBuf::from("justfile");
   let mut asts: HashMap<PathBuf, Ast> = HashMap::new();
   asts.insert(root.clone(), ast);
 
@@ -76,6 +76,7 @@ pub(crate) fn analysis_error(
           line,
           column,
           length,
+          path: "justfile".as_ref(),
         },
         kind: Box::new(kind),
       };

src/token.rs

@@ -2,12 +2,13 @@ use super::*;
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub(crate) struct Token<'src> {
-  pub(crate) offset: usize,
+  pub(crate) column: usize,
+  pub(crate) kind: TokenKind,
   pub(crate) length: usize,
   pub(crate) line: usize,
-  pub(crate) column: usize,
+  pub(crate) offset: usize,
+  pub(crate) path: &'src Path,
   pub(crate) src: &'src str,
-  pub(crate) kind: TokenKind,
 }
 
 impl<'src> Token<'src> {
@@ -52,9 +53,35 @@ impl<'src> ColorDisplay for Token<'src> {
           i += c.len_utf8();
         }
         let line_number_width = line_number.to_string().len();
-        writeln!(f, "{0:1$} |", "", line_number_width)?;
-        writeln!(f, "{line_number} | {space_line}")?;
-        write!(f, "{0:1$} |", "", line_number_width)?;
+        writeln!(
+          f,
+          "{:width$}{} {}:{}:{}",
+          "",
+          color.context().paint("-->"),
+          self.path.display(),
+          line_number,
+          self.column.ordinal(),
+          width = line_number_width
+        )?;
+        writeln!(
+          f,
+          "{:width$} {}",
+          "",
+          color.context().paint("|"),
+          width = line_number_width
+        )?;
+        writeln!(
+          f,
+          "{} {space_line}",
+          color.context().paint(&format!("{line_number} |"))
+        )?;
+        write!(
+          f,
+          "{:width$} {}",
+          "",
+          color.context().paint("|"),
+          width = line_number_width
+        )?;
         write!(
           f,
           " {0:1$}{2}{3:^<4$}{5}",