feat: improve error output details

Author: denisandroid

src/macros/include.rs

@@ -11,7 +11,12 @@ use alloc::string::String;
 use proc_macro2::{
 	Delimiter, Group, Literal, Span, TokenStream as TokenStream2, TokenTree as TokenTree2,
 };
-use std::{fs::File, io::Read};
+use std::{
+	borrow::Cow,
+	fs::File,
+	io::Read,
+	path::Path,
+};
 
 /// A trait that specifies the final behavior for the `include` macro.
 pub trait BehMacroInclude {
@@ -92,8 +97,9 @@ impl BehMacroInclude for IncludeTT {
 	) -> TreeResult<Self::Result> {
 		arg0.get_str_with_fns(
 			|sspath| {
+				let path = Path::new(sspath);
 				load_file_and_automake_tree_with_fns(
-					sspath,
+					path,
 					|_| {}, /* skip_prepare */
 					|fs_tt| {
 						let ett = match fs_tt {
@@ -138,6 +144,7 @@ impl BehMacroInclude for IncludeTTAndFixUnkStartToken {
 	) -> TreeResult<Self::Result> {
 		arg0.get_str_with_fns(
 			|sspath| {
+				let sspath = Path::new(sspath);
 				load_file_and_automake_tree_with_fns(
 					sspath,
 					|p_string| {
@@ -238,10 +245,14 @@ impl BehMacroInclude for IncludeStr {
 	) -> TreeResult<Self::Result> {
 		arg0.get_str_with_fns(
 			|sspath| {
-				let data = match std::fs::read_to_string(sspath) {
+				let path = Path::new(sspath);
+				let data = match std::fs::read_to_string(path) {
 					Ok(a) => a,
 					Err(e) => {
-						return LoadFileAndAutoMakeTreeErr::read_to_string(e, sspath)
+						let path = path
+							.canonicalize()
+							.map_or_else(|_| Cow::Borrowed(path), Cow::Owned);
+						return LoadFileAndAutoMakeTreeErr::read_to_string(e, path)
 							.into_tt_err(literal_span)
 							.into();
 					}
@@ -280,18 +291,25 @@ impl BehMacroInclude for IncludeArr {
 		arg0.get_str_with_fns(
 			|sspath| {
 				let vec = {
-					let mut file = match File::open(sspath) {
+					let path = Path::new(sspath);
+					let mut file = match File::open(path) {
 						Ok(a) => a,
 						Err(e) => {
-							return LoadFileAndAutoMakeTreeErr::read_to_string(e, sspath)
+							let path = path
+								.canonicalize()
+								.map_or_else(|_| Cow::Borrowed(path), Cow::Owned);
+							return LoadFileAndAutoMakeTreeErr::read_to_string(e, path)
 								.into_tt_err(literal_span)
 								.into();
 						}
 					};
 
 					let mut vec = Vec::new(); // capacity is not required.
 					if let Err(e) = file.read_to_end(&mut vec) {
-						return LoadFileAndAutoMakeTreeErr::read_to_string(e, sspath)
+						let path = path
+							.canonicalize()
+							.map_or_else(|_| Cow::Borrowed(path), Cow::Owned);
+						return LoadFileAndAutoMakeTreeErr::read_to_string(e, path)
 							.into_tt_err(literal_span)
 							.into();
 					};

src/trees/loader.rs

@@ -1,14 +1,14 @@
 use alloc::{format, string::String};
 use proc_macro2::{Span, TokenStream as TokenStream2};
-use std::io::Error as IOError;
+use std::{borrow::Cow, io::Error as IOError, path::Path};
 use syn::Error as SynError;
 
 /// Variants of errors when loading a file and presenting it as a set of compiler trees.
 #[derive(Debug)]
 pub enum LoadFileAndAutoMakeTreeErr<'a> {
 	/// The error type for I/O operations of the
 	/// [Read], [Write], [Seek], and associated traits.
-	ReadToString { err: IOError, path: &'a str },
+	ReadToString { err: IOError, path: Cow<'a, Path> },
 
 	/// Error returned when a Syn parser cannot parse the input tokens.
 	ParseStr(SynError),
@@ -18,24 +18,24 @@ impl<'a> LoadFileAndAutoMakeTreeErr<'a> {
 	/// The error type for I/O operations of the
 	/// [Read], [Write], [Seek], and associated traits.
 	#[inline]
-	pub const fn read_to_string(err: IOError, path: &'a str) -> Self {
+	pub const fn read_to_string(err: IOError, path: Cow<'a, Path>) -> Self {
 		Self::ReadToString { err, path }
 	}
 
 	/// Convert an error to a syntax tree.
-	#[inline]
 	pub fn into_tt_err(self, span: Span) -> TokenStream2 {
 		match self {
 			Self::ReadToString { err, path } => {
+				let spath = format!("{path:?}"); // TODO REFACTORME
 				let se = format!("{err:?}");
 				sg_err! {
-					[span]: "Error loading file, err: ", #se, ", path: ", #path, "."
+					[span]: "Error loading file, err: '", #se, "', path: ", #spath, "."
 				}
 			}
 			Self::ParseStr(e) => {
 				let se = format!("{e:?}");
 				sg_err! {
-					[span]: "Failed to convert to tree `tt`: ", #se, "."
+					[span]: "Failed to convert to tree `tt`: '", #se, "'."
 				}
 			}
 		}
@@ -45,7 +45,7 @@ impl<'a> LoadFileAndAutoMakeTreeErr<'a> {
 #[allow(dead_code)]
 /// Load the file and present it as a compiler tree set.
 pub fn load_file_and_automake_tree(
-	path: &str,
+	path: &Path,
 
 	// Preprocessing a file loaded into a String before passing it directly to the parser.
 	//
@@ -57,7 +57,7 @@ pub fn load_file_and_automake_tree(
 
 /// Load the file and present it as a compiler tree set.
 pub fn load_file_and_automake_tree_with_fns<'a, R>(
-	path: &'a str,
+	path: &'a Path,
 
 	// Preprocessing a file loaded into a String before passing it directly to the parser.
 	//
@@ -69,7 +69,12 @@ pub fn load_file_and_automake_tree_with_fns<'a, R>(
 ) -> R {
 	let mut data = match std::fs::read_to_string(path) {
 		Ok(a) => a,
-		Err(e) => return err(LoadFileAndAutoMakeTreeErr::ReadToString { err: e, path: path }),
+		Err(e) => {
+			let path = path
+				.canonicalize()
+				.map_or_else(|_| Cow::Borrowed(path), Cow::Owned);
+			return err(LoadFileAndAutoMakeTreeErr::read_to_string(e, path));
+		}
 	};
 
 	if data.is_empty() {