review: add new error case for user-provided input failures, but

should this just be a boolean in GetInputContent case?

lychee-bin/src/commands/check.rs

@@ -185,6 +185,10 @@ where
 {
     tokio::pin!(requests);
     while let Some(request) = requests.next().await {
+        if let Err(e @ RequestError::UserInputContent { .. }) = request {
+            return Err(e.into_error());
+        }
+
         if let Some(pb) = &bar {
             pb.inc_length(1);
             if let Ok(request) = &request {

lychee-bin/src/commands/dump.rs

@@ -27,6 +27,10 @@ where
     let mut writer = super::create_writer(params.cfg.output)?;
 
     while let Some(request) = requests.next().await {
+        if let Err(e @ RequestError::UserInputContent { .. }) = request {
+            return Err(e.into_error());
+        }
+
         let mut request = match request {
             Ok(x) => x,
             Err(e) => {

lychee-lib/src/types/input/input.rs

@@ -171,20 +171,24 @@ impl Input {
         resolver: UrlContentResolver,
         excluded_paths: PathExcludes,
     ) -> impl Stream<Item = std::result::Result<InputContent, RequestError>> {
-        let source = self.source.clone();
         try_stream! {
+            let source = self.source.clone();
+
+            let user_input_error = move |e: ErrorKind| RequestError::UserInputContent(source.clone(), Box::new(e));
+            let discovered_input_error = |e: ErrorKind| RequestError::GetInputContent(self.source.clone(), Box::new(e));
+
             // Handle simple cases that don't need resolution
             match self.source {
                 InputSource::RemoteUrl(url) => {
                     match resolver.url_contents(*url).await {
                         Err(_) if skip_missing => (),
-                        Err(e) => Err(e)?,
+                        Err(e) => Err(e).map_err(user_input_error)?,
                         Ok(content) => yield content,
                     }
                     return;
                 }
                 InputSource::Stdin => {
-                    yield Self::stdin_content(self.file_type_hint).await?;
+                    yield Self::stdin_content(self.file_type_hint).await.map_err(user_input_error)?;
                     return;
                 }
                 InputSource::String(ref s) => {
@@ -231,24 +235,21 @@ impl Input {
                                     log::warn!("Skipping file with invalid UTF-8 content: {}", path.display());
                                 }
                             },
-                            Err(e) => Err(e)?,
+                            Err(e) => Err(e).map_err(discovered_input_error)?,
                             Ok(content) => {
                                 sources_empty = false;
                                 yield content
                             }
                         }
                     },
-                    Err(e) => Err(e)?,
+                    Err(e) => Err(e).map_err(discovered_input_error)?,
                 }
             }
 
             if sources_empty {
                 log::warn!("{}: No files found for this input source", self.source);
             }
         }
-        .map(move |result|
-            result.map_err(|e| RequestError::GetInputContent(source.clone(), Box::new(e)))
-        )
     }
 
     /// Create a `WalkBuilder` for directory traversal

lychee-lib/src/types/request.rs

@@ -16,22 +16,30 @@ pub enum RequestError {
     /// Unable to load the content of an input source.
     #[error("Error reading input '{0}': {1}")]
     GetInputContent(InputSource, #[source] Box<ErrorKind>),
+
+    /// Unable to load an input source directly provided by the user.
+    #[error("Error reading user input '{0}': {1}")]
+    UserInputContent(InputSource, #[source] Box<ErrorKind>),
 }
 
 impl RequestError {
     /// Get the underlying cause of this [`RequestError`].
     #[must_use]
     pub const fn error(&self) -> &ErrorKind {
         match self {
-            Self::CreateRequestItem(_, _, e) | Self::GetInputContent(_, e) => e,
+            Self::CreateRequestItem(_, _, e)
+            | Self::GetInputContent(_, e)
+            | Self::UserInputContent(_, e) => e,
         }
     }
 
     /// Convert this [`RequestError`] into its source error.
     #[must_use]
     pub fn into_error(self) -> ErrorKind {
         match self {
-            Self::CreateRequestItem(_, _, e) | Self::GetInputContent(_, e) => *e,
+            Self::CreateRequestItem(_, _, e)
+            | Self::GetInputContent(_, e)
+            | Self::UserInputContent(_, e) => *e,
         }
     }
 
@@ -41,6 +49,7 @@ impl RequestError {
         match self {
             Self::CreateRequestItem(_, src, _) => src.clone().into(),
             Self::GetInputContent(src, _) => src.clone(),
+            Self::UserInputContent(src, _) => src.clone(),
         }
     }
 }