refactor(tsgolint): make MessageType parsing more idomatic (#14299)

Author: camc314

crates/oxc_linter/src/tsgolint.rs

@@ -610,17 +610,85 @@ pub struct Suggestion {
 }
 
 #[derive(Eq, PartialEq, Clone, Debug, Serialize, Deserialize)]
+#[repr(u8)]
 pub enum MessageType {
     Error = 0,
     Diagnostic = 1,
 }
 
-impl MessageType {
-    pub fn from_u8(value: u8) -> Option<Self> {
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct InvalidMessageType(pub u8);
+
+impl std::fmt::Display for InvalidMessageType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "invalid message type: {}", self.0)
+    }
+}
+
+impl std::error::Error for InvalidMessageType {}
+
+impl TryFrom<u8> for MessageType {
+    type Error = InvalidMessageType;
+
+    fn try_from(value: u8) -> Result<Self, InvalidMessageType> {
         match value {
-            0 => Some(MessageType::Error),
-            1 => Some(MessageType::Diagnostic),
-            _ => None,
+            0 => Ok(Self::Error),
+            1 => Ok(Self::Diagnostic),
+            _ => Err(InvalidMessageType(value)),
+        }
+    }
+}
+
+/// Iterator that streams messages from tsgolint stdout.
+struct TsGoLintMessageStream {
+    stdout: std::process::ChildStdout,
+    buffer: Vec<u8>,
+}
+
+impl TsGoLintMessageStream {
+    fn new(stdout: std::process::ChildStdout) -> TsGoLintMessageStream {
+        TsGoLintMessageStream { stdout, buffer: Vec::with_capacity(8192) }
+    }
+}
+
+impl Iterator for TsGoLintMessageStream {
+    type Item = Result<TsGoLintMessage, String>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut read_buf = [0u8; 8192];
+
+        loop {
+            // Try to parse a complete message from the existing buffer
+            let mut cursor = std::io::Cursor::new(self.buffer.as_slice());
+
+            if cursor.position() < self.buffer.len() as u64 {
+                let start_pos = cursor.position();
+                match parse_single_message(&mut cursor) {
+                    Ok(message) => {
+                        // Successfully parsed a message, remove it from buffer
+                        #[expect(clippy::cast_possible_truncation)]
+                        self.buffer.drain(..cursor.position() as usize);
+                        return Some(Ok(message));
+                    }
+                    Err(_) => {
+                        // Could not parse a complete message, need more data
+                        cursor.set_position(start_pos);
+                    }
+                }
+            }
+
+            // Read more data from stdout
+            match self.stdout.read(&mut read_buf) {
+                Ok(0) => {
+                    return None;
+                }
+                Ok(n) => {
+                    self.buffer.extend_from_slice(&read_buf[..n]);
+                }
+                Err(e) => {
+                    return Some(Err(format!("Failed to read from tsgolint stdout: {e}")));
+                }
+            }
         }
     }
 }
@@ -693,8 +761,8 @@ fn parse_single_message(cursor: &mut std::io::Cursor<&[u8]>) -> Result<TsGoLintM
     if cursor.read_exact(&mut message_type_byte).is_err() {
         return Err("Failed to read message type byte".to_string());
     }
-    let message_type = MessageType::from_u8(message_type_byte[0])
-        .ok_or_else(|| "Invalid message type byte".to_string())?;
+    let message_type = MessageType::try_from(message_type_byte[0])
+        .map_err(|_| "Invalid message type byte".to_string())?;
 
     let mut payload_bytes = vec![0u8; size];
     if cursor.read_exact(&mut payload_bytes).is_err() {