Struct Plan 

pub struct Plan {
    pub jobs: Vec<Job>,
    pub link: Option<LinkJob>,
    pub archive: Option<ArchiveJob>,
    pub notes: Vec<String>,
    pub output: Option<String>,
}

The whole plan for one invocation.

Fields

jobs: Vec<Job>

One per input, in command line order.

link: Option<LinkJob>

The link step, or None when a mode flag stopped short of it.

archive: Option<ArchiveJob>

The archive step, which is there only under --emit=archive and is never there beside a link: one command line produces one of the two.

notes: Vec<String>

Things worth saying under -v that are not errors, such as an object file passed on a command line that is not linking.

output: Option<String>

The argument of -o as it was written, if it was given.

Kept alongside the paths it produced because the -M family needs the name rather than the path: a make rule whose target is the object the build asked for is one the build can read back, and a rule naming a temporary directory is one nothing will ever match.

Implementations

impl Plan

pub fn new( opts: &Options, inputs: &[Input], output: Option<&str>, ) -> Result<Plan, PlanError>

Builds the plan for one invocation.

output is the argument of -o, if it was given.

Errors

Returns a message when the inputs and the mode flags do not describe a compilation: an out of scope language, -o naming one file for several outputs, or nothing to do.

pub fn render(&self) -> String

Renders the plan the way -### prints it.

One line per job, then the link line. This is meant to be read next to gcc -### output when a build behaves differently under the two compilers, so it says what will happen rather than how it is represented.

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Plan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Plan

impl PartialEq for Plan

fn eq(&self, other: &Plan) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Plan