Enum Action 

pub enum Action {
    Help,
    Version,
    Print(String),
    PrintConfig(Box<Options>),
    PrintPipeline(Box<Options>),
    PrintPlan {
        opts: Box<Options>,
        plan: Box<Plan>,
        link: Box<LinkOptions>,
    },
    Fetch {
        what: &'static Pinned,
        target: TargetTuple,
        cache: PathBuf,
    },
    Compile {
        opts: Box<Options>,
        plan: Box<Plan>,
        link: Box<LinkOptions>,
        jobs: Jobs,
        verbose: bool,
        notes: Vec<String>,
    },
}

What the command line asked for.

Variants

Help

Print usage and exit successfully.

Version

Print the version and exit successfully.

Print(String)

Print one line and exit successfully, which is what the -dump and -print family do.

A build system asks these before it compiles anything, and what it does with the answer is paste it into a path or into another command line, so each one is a single line with no decoration around it.

PrintConfig(Box<Options>)

Print the resolved configuration and exit successfully.

PrintPipeline(Box<Options>)

Print the passes the level will run and exit successfully.

PrintPlan

Print the phase plan and the link line and exit successfully, which is -###.

Fields

opts: Box<Options>

The resolved options, which is what says what the link line is for.

plan: Box<Plan>

What to do to each input, and in what order.

link: Box<LinkOptions>

What the command line said about linking.

Fetch

--fetch <tuple>, which gets the sysroot this release pins for a target and installs it.

The only action in this compiler that may run another program to move bytes onto the machine, which is spec/cross-compile/13-distribution.md section 13.8’s rule rather than a property of how this happens to be written: a compilation has no branch that reaches it.

Fields

what: &'static Pinned

The artifact, from the table in rucc_sysroot::artifact. Resolved here rather than where the work happens, so that a target nothing is pinned for is a refusal from the parser like every other thing a command line can ask for and not have.

target: TargetTuple

The target, which names the directory under the cache the tree is installed at and is checked against the record inside the artifact.

cache: PathBuf

Where the cache is, read where everything else that needs it reads it.

Compile

Compile the given inputs.

Fields

opts: Box<Options>

The resolved options.

plan: Box<Plan>

What to do to each input, and in what order.

link: Box<LinkOptions>

What the command line said about linking.

jobs: Jobs

How many translation units to compile at once.

verbose: bool

Whether -v asked for the plan to be printed while it runs.

notes: Vec<String>

What is worth saying about the command line before anything is compiled, printed as warnings and once for the whole run rather than once per file.

These are not diagnostics. A diagnostic is about a piece of source and has a span to point at, and these are about the way two flags were combined, so there is nothing to point at and nowhere below the driver that knows both halves. -w does not reach them for the same reason it does not reach a refusal from the parser.

Trait Implementations

impl Clone for Action

fn clone(&self) -> Action

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Action

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

Formats the value using the given formatter.

impl Eq for Action

impl PartialEq for Action

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Action