Add loader and refactor errors

Cargo.toml

@@ -33,6 +33,7 @@ snafu         = "0.6.0"
 strum_macros  = "0.21.1"
 target        = "1.0.0"
 tempfile      = "3.0.0"
+typed-arena   = "2.0.1"
 unicode-width = "0.1.0"
 
 [dependencies.ctrlc]
@@ -44,8 +45,10 @@ version  = "0.21.0"
 features = ["derive"]
 
 [dev-dependencies]
+cradle            = "0.0.13"
 executable-path   = "1.0.0"
 pretty_assertions = "0.7.0"
+regex             = "1.5.4"
 temptree          = "0.1.0"
 which             = "4.0.0"
 yaml-rust         = "0.4.5"

justfile

@@ -40,7 +40,7 @@ build:
 fmt:
   cargo +nightly fmt --all
 
-watch +COMMAND='test':
+watch +COMMAND='ltest':
   cargo watch --clear --exec "{{COMMAND}}"
 
 man:
@@ -61,7 +61,7 @@ version := `sed -En 's/version[[:space:]]*=[[:space:]]*"([^"]+)"/\1/p' Cargo.tom
 changes:
   git log --pretty=format:%s >> CHANGELOG.md
 
-check: clippy test forbid
+check: clippy fmt test forbid
   git diff --no-ext-diff --quiet --exit-code
   grep '^\[{{ version }}\]' CHANGELOG.md
   cargo +nightly generate-lockfile -Z minimal-versions

src/analyzer.rs

@@ -1,6 +1,6 @@
 use crate::common::*;
 
-use CompilationErrorKind::*;
+use CompileErrorKind::*;
 
 #[derive(Default)]
 pub(crate) struct Analyzer<'src> {
@@ -11,11 +11,11 @@ pub(crate) struct Analyzer<'src> {
 }
 
 impl<'src> Analyzer<'src> {
-  pub(crate) fn analyze(ast: Ast<'src>) -> CompilationResult<'src, Justfile> {
+  pub(crate) fn analyze(ast: Ast<'src>) -> CompileResult<'src, Justfile> {
     Analyzer::default().justfile(ast)
   }
 
-  pub(crate) fn justfile(mut self, ast: Ast<'src>) -> CompilationResult<'src, Justfile<'src>> {
+  pub(crate) fn justfile(mut self, ast: Ast<'src>) -> CompileResult<'src, Justfile<'src>> {
     for item in ast.items {
       match item {
         Item::Alias(alias) => {
@@ -88,7 +88,7 @@ impl<'src> Analyzer<'src> {
     })
   }
 
-  fn analyze_recipe(&self, recipe: &UnresolvedRecipe<'src>) -> CompilationResult<'src, ()> {
+  fn analyze_recipe(&self, recipe: &UnresolvedRecipe<'src>) -> CompileResult<'src, ()> {
     if let Some(original) = self.recipes.get(recipe.name.lexeme()) {
       return Err(recipe.name.token().error(DuplicateRecipe {
         recipe: original.name(),
@@ -140,7 +140,7 @@ impl<'src> Analyzer<'src> {
     Ok(())
   }
 
-  fn analyze_assignment(&self, assignment: &Assignment<'src>) -> CompilationResult<'src, ()> {
+  fn analyze_assignment(&self, assignment: &Assignment<'src>) -> CompileResult<'src, ()> {
     if self.assignments.contains_key(assignment.name.lexeme()) {
       return Err(assignment.name.token().error(DuplicateVariable {
         variable: assignment.name.lexeme(),
@@ -149,7 +149,7 @@ impl<'src> Analyzer<'src> {
     Ok(())
   }
 
-  fn analyze_alias(&self, alias: &Alias<'src, Name<'src>>) -> CompilationResult<'src, ()> {
+  fn analyze_alias(&self, alias: &Alias<'src, Name<'src>>) -> CompileResult<'src, ()> {
     let name = alias.name.lexeme();
 
     if let Some(original) = self.aliases.get(name) {
@@ -162,7 +162,7 @@ impl<'src> Analyzer<'src> {
     Ok(())
   }
 
-  fn analyze_set(&self, set: &Set<'src>) -> CompilationResult<'src, ()> {
+  fn analyze_set(&self, set: &Set<'src>) -> CompileResult<'src, ()> {
     if let Some(original) = self.sets.get(set.name.lexeme()) {
       return Err(set.name.error(DuplicateSet {
         setting: original.name.lexeme(),
@@ -176,7 +176,7 @@ impl<'src> Analyzer<'src> {
   fn resolve_alias(
     recipes: &Table<'src, Rc<Recipe<'src>>>,
     alias: Alias<'src, Name<'src>>,
-  ) -> CompilationResult<'src, Alias<'src>> {
+  ) -> CompileResult<'src, Alias<'src>> {
     let token = alias.name.token();
     // Make sure the alias doesn't conflict with any recipe
     if let Some(recipe) = recipes.get(alias.name.lexeme()) {

src/assignment_resolver.rs

@@ -1,6 +1,6 @@
 use crate::common::*;
 
-use CompilationErrorKind::*;
+use CompileErrorKind::*;
 
 pub(crate) struct AssignmentResolver<'src: 'run, 'run> {
   assignments: &'run Table<'src, Assignment<'src>>,
@@ -11,7 +11,7 @@ pub(crate) struct AssignmentResolver<'src: 'run, 'run> {
 impl<'src: 'run, 'run> AssignmentResolver<'src, 'run> {
   pub(crate) fn resolve_assignments(
     assignments: &Table<'src, Assignment<'src>>,
-  ) -> CompilationResult<'src, ()> {
+  ) -> CompileResult<'src, ()> {
     let mut resolver = AssignmentResolver {
       stack: Vec::new(),
       evaluated: BTreeSet::new(),
@@ -25,7 +25,7 @@ impl<'src: 'run, 'run> AssignmentResolver<'src, 'run> {
     Ok(())
   }
 
-  fn resolve_assignment(&mut self, name: &'src str) -> CompilationResult<'src, ()> {
+  fn resolve_assignment(&mut self, name: &'src str) -> CompileResult<'src, ()> {
     if self.evaluated.contains(name) {
       return Ok(());
     }
@@ -45,7 +45,7 @@ impl<'src: 'run, 'run> AssignmentResolver<'src, 'run> {
         length: 0,
         kind:   TokenKind::Unspecified,
       };
-      return Err(CompilationError {
+      return Err(CompileError {
         kind: Internal { message },
         token,
       });
@@ -56,7 +56,7 @@ impl<'src: 'run, 'run> AssignmentResolver<'src, 'run> {
     Ok(())
   }
 
-  fn resolve_expression(&mut self, expression: &Expression<'src>) -> CompilationResult<'src, ()> {
+  fn resolve_expression(&mut self, expression: &Expression<'src>) -> CompileResult<'src, ()> {
     match expression {
       Expression::Variable { name } => {
         let variable = name.lexeme();

src/ast.rs

@@ -1,9 +1,8 @@
 use crate::common::*;
 
-/// The top-level type produced by the parser.Not all successful parses result
+/// The top-level type produced by the parser. Not all successful parses result
 /// in valid justfiles, so additional consistency checks and name resolution
-/// are performed by the `Analyzer`, which produces a `Justfile` from an
-/// `Ast`.
+/// are performed by the `Analyzer`, which produces a `Justfile` from an `Ast`.
 #[derive(Debug, Clone)]
 pub(crate) struct Ast<'src> {
   /// Items in the justfile

src/common.rs

@@ -11,7 +11,7 @@ pub(crate) use std::{
   mem,
   ops::{Index, Range, RangeInclusive},
   path::{Path, PathBuf},
-  process::{self, Command, Stdio},
+  process::{self, Command, ExitStatus, Stdio},
   rc::Rc,
   str::{self, Chars},
   sync::{Mutex, MutexGuard},
@@ -27,6 +27,7 @@ pub(crate) use libc::EXIT_FAILURE;
 pub(crate) use log::{info, warn};
 pub(crate) use snafu::{ResultExt, Snafu};
 pub(crate) use strum::{Display, EnumString, IntoStaticStr};
+pub(crate) use typed_arena::Arena;
 pub(crate) use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
 
 // modules
@@ -37,24 +38,23 @@ pub(crate) use crate::{load_dotenv::load_dotenv, output::output, unindent::unind
 
 // traits
 pub(crate) use crate::{
-  command_ext::CommandExt, error::Error, error_result_ext::ErrorResultExt, keyed::Keyed,
-  ordinal::Ordinal, platform_interface::PlatformInterface, range_ext::RangeExt,
+  command_ext::CommandExt, keyed::Keyed, ordinal::Ordinal, platform_interface::PlatformInterface,
+  range_ext::RangeExt,
 };
 
 // structs and enums
 pub(crate) use crate::{
   alias::Alias, analyzer::Analyzer, assignment::Assignment,
   assignment_resolver::AssignmentResolver, ast::Ast, binding::Binding, color::Color,
-  compilation_error::CompilationError, compilation_error_kind::CompilationErrorKind,
-  config::Config, config_error::ConfigError, count::Count, delimiter::Delimiter,
-  dependency::Dependency, enclosure::Enclosure, evaluator::Evaluator, expression::Expression,
+  compile_error::CompileError, compile_error_kind::CompileErrorKind, config::Config,
+  config_error::ConfigError, count::Count, delimiter::Delimiter, dependency::Dependency,
+  enclosure::Enclosure, error::Error, evaluator::Evaluator, expression::Expression,
   fragment::Fragment, function::Function, function_context::FunctionContext,
   interrupt_guard::InterruptGuard, interrupt_handler::InterruptHandler, item::Item,
-  justfile::Justfile, keyword::Keyword, lexer::Lexer, line::Line, list::List,
-  load_error::LoadError, name::Name, output_error::OutputError, parameter::Parameter,
-  parameter_kind::ParameterKind, parser::Parser, platform::Platform, position::Position,
-  positional::Positional, recipe::Recipe, recipe_context::RecipeContext,
-  recipe_resolver::RecipeResolver, runtime_error::RuntimeError, scope::Scope, search::Search,
+  justfile::Justfile, keyword::Keyword, lexer::Lexer, line::Line, list::List, loader::Loader,
+  name::Name, output_error::OutputError, parameter::Parameter, parameter_kind::ParameterKind,
+  parser::Parser, platform::Platform, position::Position, positional::Positional, recipe::Recipe,
+  recipe_context::RecipeContext, recipe_resolver::RecipeResolver, scope::Scope, search::Search,
   search_config::SearchConfig, search_error::SearchError, set::Set, setting::Setting,
   settings::Settings, shebang::Shebang, show_whitespace::ShowWhitespace, string_kind::StringKind,
   string_literal::StringLiteral, subcommand::Subcommand, suggestion::Suggestion, table::Table,
@@ -64,9 +64,9 @@ pub(crate) use crate::{
 };
 
 // type aliases
-pub(crate) type CompilationResult<'a, T> = Result<T, CompilationError<'a>>;
+pub(crate) type CompileResult<'a, T> = Result<T, CompileError<'a>>;
 pub(crate) type ConfigResult<T> = Result<T, ConfigError>;
-pub(crate) type RunResult<'a, T> = Result<T, RuntimeError<'a>>;
+pub(crate) type RunResult<'a, T> = Result<T, Error<'a>>;
 pub(crate) type SearchResult<T> = Result<T, SearchError>;
 
 // modules used in tests