Struct RustBuild 

pub struct RustBuild {
    pub target: String,
    pub features: Vec<String>,
    pub cfgs: Vec<String>,
    pub compiler_version: String,
    pub opt_level: String,
    pub lto: String,
    pub codegen_units: Option<u32>,
    pub panic: String,
    pub lockfile_hash: Option<String>,
    pub build_command_hash: Option<String>,
    pub post_processing_tools: Vec<String>,
    pub permitted_execution: Vec<String>,
}

What a Rust crate was built with.

Recorded rather than assumed: a helper analyses with the compiler it holds, which need not be the one the project builds with, so the version here is the one that produced the answers.

Fields

target: String

The target triple.

features: Vec<String>

Enabled cargo features, deduplicated and sorted: they are a set, and nothing about the order they were requested in reaches the compiler.

Each names the package it belongs to, because a feature is declared per package: one package’s derive and another’s are unrelated, and a bare list would let either stand for both.

cfgs: Vec<String>

--cfg settings, deduplicated and sorted for the same reason.

compiler_version: String

The compiler that produced the answers.

opt_level: String

Optimization level, as cargo spells it.

lto: String

Link-time optimization setting.

codegen_units: Option<u32>

Codegen units, when pinned.

panic: String

Panic strategy.

lockfile_hash: Option<String>

A hash of Cargo.lock: the dependency versions are part of what the source means, and the lockfile is the only place that records them all.

build_command_hash: Option<String>

A hash of the command the build was requested with.

post_processing_tools: Vec<String>

Post-processing tools declared for this build, in invocation order.

This records build context only. The source scanner never executes a declared tool.

permitted_execution: Vec<String>

The classes of execution the run was permitted, sorted and named as a person types them.

Part of the identity because a run allowed to run build scripts reads a program the refused run cannot see: types that only exist after a script has written them resolve in one and not the other. What was permitted rather than what turned out to run — the second is a prediction this side would have to make before doing the work, and a prediction that came out wrong would file the answers under conditions that did not hold.

Implementations

impl RustBuild

pub fn normalized(self) -> Self

The same build with its features and cfgs reduced to sets.

pub fn settings(&self) -> Vec<Setting>

Everything this build was told, in the order the identity encodes it.

Trait Implementations

impl Clone for RustBuild

fn clone(&self) -> RustBuild

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RustBuild

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

Formats the value using the given formatter.

impl Default for RustBuild

fn default() -> RustBuild

Returns the “default value” for a type.

impl Eq for RustBuild

impl PartialEq for RustBuild

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RustBuild