beam-compiler

[Prestgg1]

`
#[derive(Debug)]
pub struct BeamCompilerInstance {
process: Child,
stdin: Option,
stdout: BufReader,
// A guard held for cleaning up the temporary file used to start the BEAM instance.
_source: tempfile::NamedTempFile,
}

impl BeamCompilerInstance {
pub fn compile(
&mut self,
out: &Utf8Path,
lib: &Utf8Path,
modules: &HashSet,
stdio: Stdio,
) -> Result<Vec, Error> {
// Check that the BEAM instance is still alive before attempting to use it.
let exit_status = self
.process
.try_wait()
.expect("access BEAM instance exit state");
if let Some(status) = exit_status {
panic!("BEAM compiler instance exited: {status}");
}

    // Prepare work to send to the BEAM instance.
    let args = format!(
        "{{\"{}\", \"{}\", [\"{}\"]}}",
        escape_path(lib),
        escape_path(out.join("ebin")),
        modules
            .iter()
            .map(|module| escape_path(out.join(paths::ARTEFACT_DIRECTORY_NAME).join(module)))
            .join("\", \"")
    );

    tracing::debug!(args=?args, "call_beam_compiler");

    writeln!(self.stdin.as_ref().expect("stdin present"), "{args}.").map_err(|error| {
        Error::ShellCommand {
            program: "escript".into(),
            reason: ShellCommandFailureReason::IoError(error.kind()),
        }
    })?;

    let mut buf = String::new();
    let mut accumulated_modules: Vec<String> = Vec::new();
    while let (Ok(_), Ok(None)) = (self.stdout.read_line(&mut buf), self.process.try_wait()) {
        match buf.trim() {
            "gleam-compile-result-ok" => {
                // Return Ok with the accumulated modules
                return Ok(accumulated_modules);
            }
            "gleam-compile-result-error" => {
                return Err(Error::ShellCommand {
                    program: "escript".into(),
                    reason: ShellCommandFailureReason::Unknown,
                });
            }
            s if s.starts_with("gleam-compile-module:") => {
                if let Some(module_content) = s.strip_prefix("gleam-compile-module:") {
                    accumulated_modules.push(module_content.to_string());
                }
            }
            _ => match stdio {
                Stdio::Inherit => print!("{buf}"),
                Stdio::Null => {}
            },
        }

        buf.clear();
    }


    Err(Error::ShellCommand {
        program: "escript".into(),
        reason: ShellCommandFailureReason::Unknown,
    })`  

In this gleam's source code I think, we can change stdout type as a enum. And then we can write this code much more predictable

match self.stdout {
Stdout::GleamCompileResultOk => {
// Return Ok with the accumulated modules
return Ok(accumulated_modules);
}
Stdout::GleamCompileResultErr => {
return Err(Error::ShellCommand {
program: "escript".into(),
reason: ShellCommandFailureReason::Unknown,
});
}
Stdout::GleamCompileModule(module_content) => {
accumulated_modules.push(module_content);
}
_ => match stdio {
Stdio::Inherit => print!("{buf}"),
Stdio::Null => {}
},

[lpil]

That string comes from the stdio of a child OS process, it is not from elsewhere in the Rust program so it cannot be a Rust enum.