Refactor Error Types

src/nixpkgs_problem.rs

@@ -79,31 +79,7 @@ pub enum NixpkgsProblem {
         subpath: RelativePathBuf,
         io_error: String,
     },
-    PathInterpolation {
-        relative_package_dir: RelativePathBuf,
-        subpath: RelativePathBuf,
-        line: usize,
-        text: String,
-    },
-    SearchPath {
-        relative_package_dir: RelativePathBuf,
-        subpath: RelativePathBuf,
-        line: usize,
-        text: String,
-    },
-    OutsidePathReference {
-        relative_package_dir: RelativePathBuf,
-        subpath: RelativePathBuf,
-        line: usize,
-        text: String,
-    },
-    UnresolvablePathReference {
-        relative_package_dir: RelativePathBuf,
-        subpath: RelativePathBuf,
-        line: usize,
-        text: String,
-        io_error: String,
-    },
+    NixFileProblem(NixFileError),
     RatchetProblem(RatchetError),
     InternalCallPackageUsed {
         attr_name: String,
@@ -126,6 +102,23 @@ pub enum ShardErrorKind {
     CaseSensitiveDuplicate { first: OsString, second: OsString },
 }
 
+#[derive(Clone)]
+pub struct NixFileError {
+    pub relative_package_dir: RelativePathBuf,
+    pub subpath: RelativePathBuf,
+    pub line: usize,
+    pub text: String,
+    pub kind: NixFileErrorKind,
+}
+
+#[derive(Clone)]
+pub enum NixFileErrorKind {
+    PathInterpolation,
+    SearchPath,
+    OutsidePathReference,
+    UnresolvablePathReference { io_error: String },
+}
+
 #[derive(Clone)]
 pub struct RatchetError {
     pub package_name: String,
@@ -306,26 +299,36 @@ impl fmt::Display for NixpkgsProblem {
                     f,
                     "{relative_package_dir}: Path {subpath} is a symlink which cannot be resolved: {io_error}.",
                 ),
-            NixpkgsProblem::PathInterpolation { relative_package_dir, subpath, line, text } =>
-                write!(
-                    f,
-                    "{relative_package_dir}: File {subpath} at line {line} contains the path expression \"{text}\", which is not yet supported and may point outside the directory of that package.",
-                ),
-            NixpkgsProblem::SearchPath { relative_package_dir, subpath, line, text } =>
-                write!(
-                    f,
-                    "{relative_package_dir}: File {subpath} at line {line} contains the nix search path expression \"{text}\" which may point outside the directory of that package.",
-                ),
-            NixpkgsProblem::OutsidePathReference { relative_package_dir, subpath, line, text } =>
-                write!(
-                    f,
-                    "{relative_package_dir}: File {subpath} at line {line} contains the path expression \"{text}\" which may point outside the directory of that package.",
-                ),
-            NixpkgsProblem::UnresolvablePathReference { relative_package_dir, subpath, line, text, io_error } =>
-                write!(
-                    f,
-                    "{relative_package_dir}: File {subpath} at line {line} contains the path expression \"{text}\" which cannot be resolved: {io_error}.",
-                ),
+            NixpkgsProblem::NixFileProblem(NixFileError {
+                relative_package_dir,
+                subpath,
+                line,
+                text,
+                kind
+            }) => {
+                match kind {
+                    NixFileErrorKind::PathInterpolation =>
+                        write!(
+                            f,
+                            "{relative_package_dir}: File {subpath} at line {line} contains the path expression \"{text}\", which is not yet supported and may point outside the directory of that package.",
+                        ),
+                    NixFileErrorKind::SearchPath =>
+                        write!(
+                            f,
+                            "{relative_package_dir}: File {subpath} at line {line} contains the nix search path expression \"{text}\" which may point outside the directory of that package.",
+                        ),
+                    NixFileErrorKind::OutsidePathReference =>
+                        write!(
+                            f,
+                            "{relative_package_dir}: File {subpath} at line {line} contains the path expression \"{text}\" which may point outside the directory of that package.",
+                        ),
+                    NixFileErrorKind::UnresolvablePathReference { io_error } =>
+                        write!(
+                            f,
+                            "{relative_package_dir}: File {subpath} at line {line} contains the path expression \"{text}\" which cannot be resolved: {io_error}.",
+                        ),
+                }
+            },
             NixpkgsProblem::RatchetProblem(RatchetError {
                 package_name,
                 call_package_path,

src/references.rs

@@ -1,4 +1,4 @@
-use crate::nixpkgs_problem::NixpkgsProblem;
+use crate::nixpkgs_problem::{NixFileError, NixFileErrorKind, NixpkgsProblem};
 use crate::utils;
 use crate::validation::{self, ResultIteratorExt, Validation::Success};
 use crate::NixFileStore;
@@ -125,51 +125,39 @@ fn check_nix_file(
 
     Ok(validation::sequence_(
         nix_file.syntax_root.syntax().descendants().map(|node| {
-            let text = node.text().to_string();
-            let line = nix_file.line_index.line(node.text_range().start().into());
-
             // We're only interested in Path expressions
-            let Some(path) = rnix::ast::Path::cast(node) else {
+            let Some(path) = rnix::ast::Path::cast(node.clone()) else {
                 return Success(());
             };
 
             use crate::nix_file::ResolvedPath;
 
-            match nix_file.static_resolve_path(path, absolute_package_dir) {
-                ResolvedPath::Interpolated => NixpkgsProblem::PathInterpolation {
-                    relative_package_dir: relative_package_dir.to_owned(),
-                    subpath: subpath.to_owned(),
-                    line,
-                    text,
-                }
-                .into(),
-                ResolvedPath::SearchPath => NixpkgsProblem::SearchPath {
-                    relative_package_dir: relative_package_dir.to_owned(),
-                    subpath: subpath.to_owned(),
-                    line,
-                    text,
+            let error_or_none = match nix_file.static_resolve_path(path, absolute_package_dir) {
+                ResolvedPath::Interpolated => Some(NixFileErrorKind::PathInterpolation),
+                ResolvedPath::SearchPath => Some(NixFileErrorKind::SearchPath),
+                ResolvedPath::Outside => Some(NixFileErrorKind::OutsidePathReference),
+                ResolvedPath::Unresolvable(e) => {
+                    Some(NixFileErrorKind::UnresolvablePathReference {
+                        io_error: e.to_string(),
+                    })
                 }
-                .into(),
-                ResolvedPath::Outside => NixpkgsProblem::OutsidePathReference {
-                    relative_package_dir: relative_package_dir.to_owned(),
-                    subpath: subpath.to_owned(),
-                    line,
-                    text,
-                }
-                .into(),
-                ResolvedPath::Unresolvable(e) => NixpkgsProblem::UnresolvablePathReference {
-                    relative_package_dir: relative_package_dir.to_owned(),
-                    subpath: subpath.to_owned(),
-                    line,
-                    text,
-                    io_error: e.to_string(),
-                }
-                .into(),
                 ResolvedPath::Within(..) => {
                     // No need to handle the case of it being inside the directory, since we scan through the
                     // entire directory recursively anyways
-                    Success(())
+                    None
                 }
+            };
+            if let Some(kind) = error_or_none {
+                NixpkgsProblem::NixFileProblem(NixFileError {
+                    relative_package_dir: relative_package_dir.to_owned(),
+                    subpath: subpath.to_owned(),
+                    line: nix_file.line_index.line(node.text_range().start().into()),
+                    text: node.text().to_string(),
+                    kind,
+                })
+                .into()
+            } else {
+                Success(())
             }
         }),
     ))