Enum target_spec::TargetSpec

source ·
pub enum TargetSpec {
    Expression(TargetSpecExpression),
    PlainString(TargetSpecPlainString),
}
Expand description

A parsed target specification or triple string, as found in a Cargo.toml file.

§Expressions and triple strings

Cargo supports platform-specific dependencies. These dependencies can be specified in one of two ways:

# 1. As Rust-like `#[cfg]` syntax.
[target.'cfg(all(unix, target_arch = "x86_64"))'.dependencies]
native = { path = "native/x86_64" }

# 2. Listing out the full target triple.
[target.x86_64-pc-windows-gnu.dependencies]
winhttp = "0.4.0"

§The cfg() syntax

The first cfg() syntax is represented via the TargetSpec::Expression variant. This variant represents an arbitrary expression against certain properties of the target. To evaluate a Platform against this variant, target-spec builds an expression tree (currently via cfg-expr).

§Plain string syntax

The second syntax, listing just the name of a platform, is represented via the TargetSpec::PlainString variant. In target-spec’s model, the contained data is arbitrary and used only for string comparisons. For example, TargetSpec::PlainString("x86_64-pc-windows-gnu") will match the x86_64-pc-windows-gnu platform.

target-spec checks that the string looks sufficiently like a triple. This check is duplicated from Cargo’s own check and is implemented in Self::looks_like_plain_string.

§Examples

use target_spec::{Platform, TargetFeatures, TargetSpec};

let i686_windows = Platform::new("i686-pc-windows-gnu", TargetFeatures::Unknown).unwrap();
let x86_64_mac = Platform::new("x86_64-apple-darwin", TargetFeatures::none()).unwrap();
let i686_linux = Platform::new(
    "i686-unknown-linux-gnu",
    TargetFeatures::features(["sse2"].iter().copied()),
).unwrap();

let spec: TargetSpec = "cfg(any(windows, target_arch = \"x86_64\"))".parse().unwrap();
assert_eq!(spec.eval(&i686_windows), Some(true), "i686 Windows");
assert_eq!(spec.eval(&x86_64_mac), Some(true), "x86_64 MacOS");
assert_eq!(spec.eval(&i686_linux), Some(false), "i686 Linux (should not match)");

let spec: TargetSpec = "cfg(any(target_feature = \"sse2\", target_feature = \"sse\"))".parse().unwrap();
assert_eq!(spec.eval(&i686_windows), None, "i686 Windows features are unknown");
assert_eq!(spec.eval(&x86_64_mac), Some(false), "x86_64 MacOS matches no features");
assert_eq!(spec.eval(&i686_linux), Some(true), "i686 Linux matches some features");

Variants§

§

Expression(TargetSpecExpression)

A complex expression.

Parsed from strings like "cfg(any(windows, target_arch = \"x86_64\"))".

§

PlainString(TargetSpecPlainString)

A plain string representing a triple.

This string hasn’t been validated because it may represent a custom platform. To validate this string, use Self::is_known.

Implementations§

source§

impl TargetSpec

source

pub fn new(input: impl Into<Cow<'static, str>>) -> Result<Self, Error>

Creates a new target spec from a string.

source

pub fn looks_like_expression(input: &str) -> bool

Returns true if the input will be parsed as a target expression.

In other words, returns true if the input begins with "cfg(".

source

pub fn looks_like_plain_string(input: &str) -> bool

Returns true if the input will be understood to be a plain string.

This check is borrowed from cargo-platform.

Note that this currently accepts an empty string. This matches Cargo’s behavior as of Rust 1.70.

source

pub fn is_known(&self) -> bool

Returns true if an input looks like it’s known and understood.

This method does not take into account custom platforms. If you know about custom platforms, consider checking against those as well.

source

pub fn eval(&self, platform: &Platform) -> Option<bool>

Evaluates this specification against the given platform.

Returns Some(true) if there’s a match, Some(false) if there’s none, or None if the result of the evaluation is unknown (typically found if target features are involved).

Trait Implementations§

source§

impl Clone for TargetSpec

source§

fn clone(&self) -> TargetSpec

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for TargetSpec

source§

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

Formats the value using the given formatter. Read more
source§

impl Display for TargetSpec

source§

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

Formats the value using the given formatter. Read more
source§

impl FromStr for TargetSpec

§

type Err = Error

The associated error which can be returned from parsing.
source§

fn from_str(input: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.