Enum target_spec::TargetSpec

pub enum TargetSpec {
    Expression(TargetSpecExpression),
    PlainString(TargetSpecPlainString),
}

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

impl TargetSpec

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

Creates a new target spec from a string.

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(".

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.

pub fn is_known(&self) -> bool

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

• For Self::Expression, the inner TargetSpecExpression has already been parsed as valid, so this returns true.
• For Self::PlainString, this returns true if the string matches a builtin triple or has heuristically been determined to be valid.

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

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

impl Clone for TargetSpec

fn clone(&self) -> TargetSpec

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TargetSpec

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

Formats the value using the given formatter.

impl Display for TargetSpec

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

Formats the value using the given formatter.

impl FromStr for TargetSpec

type Err = Error

The associated error which can be returned from parsing.

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

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