0b7ba6ec54
This commit rejiggers the generics used in the implementation of
`Command::env` with the purpose of reducing the amount of codegen that
needs to happen in consumer crates, instead preferring to generate code
into libstd.
This was found when profiling the compile times of the `cc` crate where
the binary rlib produced had a lot of `BTreeMap` code compiled into it
but the crate doesn't actually use `BTreeMap`. It turns out that
`Command::env` is generic enough to codegen the entire implementation in
calling crates, but in this case there's no performance concern so it's
fine to compile the code into the standard library.
This change is done by removing the generic on the `CommandEnv` map
which is intended to handle case-insensitive variables on Windows.
Instead now a generic isn't used but rather a `use` statement defined
per-platform is used.
With this commit a debug build of `Command::new("foo").env("a", "b")`
drops from 21k lines of LLVM IR to 10k.
154 lines
2.9 KiB
Rust
154 lines
2.9 KiB
Rust
use crate::ffi::OsStr;
|
|
use crate::fmt;
|
|
use crate::io;
|
|
use crate::sys::fs::File;
|
|
use crate::sys::pipe::AnonPipe;
|
|
use crate::sys::{unsupported, Void};
|
|
use crate::sys_common::process::CommandEnv;
|
|
|
|
pub use crate::ffi::OsString as EnvKey;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Command
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
pub struct Command {
|
|
env: CommandEnv
|
|
}
|
|
|
|
// passed back to std::process with the pipes connected to the child, if any
|
|
// were requested
|
|
pub struct StdioPipes {
|
|
pub stdin: Option<AnonPipe>,
|
|
pub stdout: Option<AnonPipe>,
|
|
pub stderr: Option<AnonPipe>,
|
|
}
|
|
|
|
pub enum Stdio {
|
|
Inherit,
|
|
Null,
|
|
MakePipe,
|
|
}
|
|
|
|
impl Command {
|
|
pub fn new(_program: &OsStr) -> Command {
|
|
Command {
|
|
env: Default::default()
|
|
}
|
|
}
|
|
|
|
pub fn arg(&mut self, _arg: &OsStr) {
|
|
}
|
|
|
|
pub fn env_mut(&mut self) -> &mut CommandEnv {
|
|
&mut self.env
|
|
}
|
|
|
|
pub fn cwd(&mut self, _dir: &OsStr) {
|
|
}
|
|
|
|
pub fn stdin(&mut self, _stdin: Stdio) {
|
|
}
|
|
|
|
pub fn stdout(&mut self, _stdout: Stdio) {
|
|
}
|
|
|
|
pub fn stderr(&mut self, _stderr: Stdio) {
|
|
}
|
|
|
|
pub fn spawn(&mut self, _default: Stdio, _needs_stdin: bool)
|
|
-> io::Result<(Process, StdioPipes)> {
|
|
unsupported()
|
|
}
|
|
}
|
|
|
|
impl From<AnonPipe> for Stdio {
|
|
fn from(pipe: AnonPipe) -> Stdio {
|
|
pipe.diverge()
|
|
}
|
|
}
|
|
|
|
impl From<File> for Stdio {
|
|
fn from(_file: File) -> Stdio {
|
|
panic!("unsupported")
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for Command {
|
|
fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub struct ExitStatus(Void);
|
|
|
|
impl ExitStatus {
|
|
pub fn success(&self) -> bool {
|
|
match self.0 {}
|
|
}
|
|
|
|
pub fn code(&self) -> Option<i32> {
|
|
match self.0 {}
|
|
}
|
|
}
|
|
|
|
impl Clone for ExitStatus {
|
|
fn clone(&self) -> ExitStatus {
|
|
match self.0 {}
|
|
}
|
|
}
|
|
|
|
impl Copy for ExitStatus {}
|
|
|
|
impl PartialEq for ExitStatus {
|
|
fn eq(&self, _other: &ExitStatus) -> bool {
|
|
match self.0 {}
|
|
}
|
|
}
|
|
|
|
impl Eq for ExitStatus {
|
|
}
|
|
|
|
impl fmt::Debug for ExitStatus {
|
|
fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self.0 {}
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for ExitStatus {
|
|
fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self.0 {}
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
|
|
pub struct ExitCode(bool);
|
|
|
|
impl ExitCode {
|
|
pub const SUCCESS: ExitCode = ExitCode(false);
|
|
pub const FAILURE: ExitCode = ExitCode(true);
|
|
|
|
pub fn as_i32(&self) -> i32 {
|
|
self.0 as i32
|
|
}
|
|
}
|
|
|
|
pub struct Process(Void);
|
|
|
|
impl Process {
|
|
pub fn id(&self) -> u32 {
|
|
match self.0 {}
|
|
}
|
|
|
|
pub fn kill(&mut self) -> io::Result<()> {
|
|
match self.0 {}
|
|
}
|
|
|
|
pub fn wait(&mut self) -> io::Result<ExitStatus> {
|
|
match self.0 {}
|
|
}
|
|
|
|
pub fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
|
|
match self.0 {}
|
|
}
|
|
}
|