Deny unreachable pub (#3080)

Author: casey

Cargo.toml

@@ -66,10 +66,11 @@ which = "8.0.0"
 [lints.rust]
 mismatched_lifetime_syntaxes = "allow"
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(fuzzing)'] }
+unreachable_pub = "deny"
 
 [lints.clippy]
 all = { level = "deny", priority = -1 }
-arbitrary-source-item-ordering = "deny"
+arbitrary_source_item_ordering = "deny"
 enum_glob_use = "allow"
 ignore_without_reason = "allow"
 needless_pass_by_value = "allow"

src/compile_error.rs

@@ -11,7 +11,7 @@ impl<'src> CompileError<'src> {
     self.token
   }
 
-  pub(crate) fn new(token: Token<'src>, kind: CompileErrorKind<'src>) -> CompileError<'src> {
+  pub(crate) fn new(token: Token<'src>, kind: CompileErrorKind<'src>) -> Self {
     Self {
       token,
       kind: kind.into(),

src/count.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-pub struct Count<T: Display>(pub T, pub usize);
+pub(crate) struct Count<T: Display>(pub T, pub usize);
 
 impl<T: Display> Display for Count<T> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {

src/enclosure.rs

@@ -1,12 +1,12 @@
 use super::*;
 
-pub struct Enclosure<T: Display> {
+pub(crate) struct Enclosure<T: Display> {
   enclosure: &'static str,
   value: T,
 }
 
 impl<T: Display> Enclosure<T> {
-  pub fn tick(value: T) -> Enclosure<T> {
+  pub(crate) fn tick(value: T) -> Self {
     Self {
       enclosure: "`",
       value,

src/error.rs

@@ -329,8 +329,8 @@ impl<'src> From<ConstError<'src>> for Error<'src> {
   }
 }
 
-impl<'src> From<dotenvy::Error> for Error<'src> {
-  fn from(dotenv_error: dotenvy::Error) -> Error<'src> {
+impl From<dotenvy::Error> for Error<'_> {
+  fn from(dotenv_error: dotenvy::Error) -> Self {
     Self::Dotenv { dotenv_error }
   }
 }

src/expression.rs

@@ -9,15 +9,12 @@ use super::*;
 #[derive(PartialEq, Debug, Clone)]
 pub(crate) enum Expression<'src> {
   /// `lhs && rhs`
-  And {
-    lhs: Box<Expression<'src>>,
-    rhs: Box<Expression<'src>>,
-  },
+  And { lhs: Box<Self>, rhs: Box<Self> },
   /// `assert(condition, error)`
   Assert {
     name: Name<'src>,
     condition: Condition<'src>,
-    error: Box<Expression<'src>>,
+    error: Box<Self>,
   },
   /// `contents`
   Backtick {
@@ -27,33 +24,27 @@ pub(crate) enum Expression<'src> {
   /// `name(arguments)`
   Call { thunk: Thunk<'src> },
   /// `lhs + rhs`
-  Concatenation {
-    lhs: Box<Expression<'src>>,
-    rhs: Box<Expression<'src>>,
-  },
+  Concatenation { lhs: Box<Self>, rhs: Box<Self> },
   /// `if condition { then } else { otherwise }`
   Conditional {
     condition: Condition<'src>,
-    then: Box<Expression<'src>>,
-    otherwise: Box<Expression<'src>>,
+    then: Box<Self>,
+    otherwise: Box<Self>,
   },
   // `f"format string"`
   FormatString {
     start: StringLiteral<'src>,
-    expressions: Vec<(Expression<'src>, StringLiteral<'src>)>,
+    expressions: Vec<(Self, StringLiteral<'src>)>,
   },
   /// `(contents)`
-  Group { contents: Box<Expression<'src>> },
+  Group { contents: Box<Self> },
   /// `lhs / rhs`
   Join {
-    lhs: Option<Box<Expression<'src>>>,
-    rhs: Box<Expression<'src>>,
+    lhs: Option<Box<Self>>,
+    rhs: Box<Self>,
   },
   /// `lhs || rhs`
-  Or {
-    lhs: Box<Expression<'src>>,
-    rhs: Box<Expression<'src>>,
-  },
+  Or { lhs: Box<Self>, rhs: Box<Self> },
   /// `"string_literal"` or `'string_literal'`
   StringLiteral { string_literal: StringLiteral<'src> },
   /// `variable`

src/justfile.rs

@@ -12,7 +12,7 @@ pub(crate) struct Justfile<'src> {
   pub(crate) loaded: Vec<PathBuf>,
   #[serde(skip)]
   pub(crate) module_path: String,
-  pub(crate) modules: Table<'src, Justfile<'src>>,
+  pub(crate) modules: Table<'src, Self>,
   #[serde(skip)]
   pub(crate) name: Option<Name<'src>>,
   #[serde(skip)]
@@ -80,7 +80,7 @@ impl<'src> Justfile<'src> {
     config: &'run Config,
     dotenv: &'run BTreeMap<String, String>,
     root: &'run Scope<'src, 'run>,
-    scopes: &mut BTreeMap<String, (&'run Justfile<'src>, &'run Scope<'src, 'run>)>,
+    scopes: &mut BTreeMap<String, (&'run Self, &'run Scope<'src, 'run>)>,
     search: &'run Search,
   ) -> RunResult<'src> {
     let scope = Evaluator::evaluate_assignments(config, dotenv, self, root, search)?;
@@ -265,15 +265,19 @@ impl<'src> Justfile<'src> {
     is_dependency: bool,
     ran: &Ran,
     recipe: &Recipe<'src>,
-    scopes: &BTreeMap<String, (&Justfile<'src>, &Scope<'src, '_>)>,
+    scopes: &BTreeMap<String, (&Self, &Scope<'src, '_>)>,
     search: &Search,
   ) -> RunResult<'src> {
-    let mutex = ran.mutex(recipe, arguments);
+    {
+      let mutex = ran.mutex(recipe, arguments);
 
-    let mut guard = mutex.lock().unwrap();
+      let mut guard = mutex.lock().unwrap();
 
-    if *guard {
-      return Ok(());
+      if *guard {
+        return Ok(());
+      }
+
+      *guard = true;
     }
 
     if !config.yes && !recipe.confirm()? {
@@ -332,8 +336,6 @@ impl<'src> Justfile<'src> {
       search,
     )?;
 
-    *guard = true;
-
     Ok(())
   }
 
@@ -345,7 +347,7 @@ impl<'src> Justfile<'src> {
     evaluator: &mut Evaluator<'src, 'run>,
     ran: &Ran,
     recipe: &Recipe<'src>,
-    scopes: &BTreeMap<String, (&Justfile<'src>, &Scope<'src, 'run>)>,
+    scopes: &BTreeMap<String, (&Self, &Scope<'src, 'run>)>,
     search: &Search,
   ) -> RunResult<'src> {
     if context.config.no_dependencies {

src/keyword.rs

@@ -38,7 +38,7 @@ pub(crate) enum Keyword {
 }
 
 impl Keyword {
-  pub(crate) fn from_lexeme(lexeme: &str) -> Option<Keyword> {
+  pub(crate) fn from_lexeme(lexeme: &str) -> Option<Self> {
     lexeme.parse().ok()
   }
 

src/list.rs

@@ -1,32 +1,32 @@
 use super::*;
 
-pub struct List<T: Display, I: Iterator<Item = T> + Clone> {
+pub(crate) struct List<T: Display, I: Iterator<Item = T> + Clone> {
   conjunction: &'static str,
   values: I,
 }
 
 impl<T: Display, I: Iterator<Item = T> + Clone> List<T, I> {
-  pub fn or<II: IntoIterator<Item = T, IntoIter = I>>(values: II) -> Self {
+  pub(crate) fn or<II: IntoIterator<Item = T, IntoIter = I>>(values: II) -> Self {
     Self {
       conjunction: "or",
       values: values.into_iter(),
     }
   }
 
-  pub fn and<II: IntoIterator<Item = T, IntoIter = I>>(values: II) -> Self {
+  pub(crate) fn and<II: IntoIterator<Item = T, IntoIter = I>>(values: II) -> Self {
     Self {
       conjunction: "and",
       values: values.into_iter(),
     }
   }
 
-  pub fn or_ticked<II: IntoIterator<Item = T, IntoIter = I>>(
+  pub(crate) fn or_ticked<II: IntoIterator<Item = T, IntoIter = I>>(
     values: II,
   ) -> List<Enclosure<T>, impl Iterator<Item = Enclosure<T>> + Clone> {
     List::or(values.into_iter().map(Enclosure::tick))
   }
 
-  pub fn and_ticked<II: IntoIterator<Item = T, IntoIter = I>>(
+  pub(crate) fn and_ticked<II: IntoIterator<Item = T, IntoIter = I>>(
     values: II,
   ) -> List<Enclosure<T>, impl Iterator<Item = Enclosure<T>> + Clone> {
     List::and(values.into_iter().map(Enclosure::tick))

src/output_error.rs

@@ -17,7 +17,7 @@ pub(crate) enum OutputError {
 }
 
 impl OutputError {
-  pub(crate) fn result_from_exit_status(exit_status: ExitStatus) -> Result<(), OutputError> {
+  pub(crate) fn result_from_exit_status(exit_status: ExitStatus) -> Result<(), Self> {
     match exit_status.code() {
       Some(0) => Ok(()),
       Some(code) => Err(Self::Code(code)),