Enum StandardViolation 

pub enum StandardViolation {
    MsvcSpelling {
        target: String,
        language: &'static str,
        standard: &'static str,
        object: Utf8PathBuf,
    },
    MsvcGnuExtensions {
        target: String,
        object: Utf8PathBuf,
    },
    FlagConflict {
        conflict: StandardFlagConflict,
        object: Utf8PathBuf,
    },
    InterfaceIncompatibility {
        consumer: String,
        dependency: String,
        language: &'static str,
        consumer_standard: &'static str,
        required: &'static str,
        requirement_source: &'static str,
        object: Utf8PathBuf,
    },
}

One standards problem recorded against a planned compile. Each variant carries the offending compile’s object path so the cabin check rewrite can prune violations with the same path filter as the compiles they belong to.

Variants

MsvcSpelling

An MSVC-dialect compile whose standard cl.exe has no stable /std: flag - the planner cannot lower it (its compile-commands entry is omitted).

Fields

target: String

package:target of the offending compile.

language: &'static str

Human label of the source language (C / C++).

standard: &'static str

Canonical spelling of the offending standard.

object: Utf8PathBuf

Object path of the offending compile.

MsvcGnuExtensions

An MSVC-dialect compile whose target enables gnu-extensions - cl.exe has no GNU dialect mode, so the planner cannot honor the flag and must not silently ignore it (its compile-commands entry is omitted).

Fields

target: String

package:target of the offending compile.

object: Utf8PathBuf

Object path of the offending compile.

FlagConflict

A compile that carries both a first-class standard declaration and an explicit -std= / /std: token in its manifest-derived flag list - the documented escape-hatch ambiguity, scoped to compiles the declaration covers.

Fields

conflict: StandardFlagConflict

object: Utf8PathBuf

Object path of the offending compile.

InterfaceIncompatibility

A consuming compile whose effective implementation standard is below a reachable library-like dependency’s interface requirement for the same language. Recorded against the consumer’s compile so the cabin check rewrite prunes the incompatibility together with the compiles it protects - a dependency-internal incompatibility never gates a check that only compiles the selected packages’ own translation units.

Fields

consumer: String

dependency: String

language: &'static str

consumer_standard: &'static str

required: &'static str

requirement_source: &'static str

object: Utf8PathBuf

Object path of one of the consumer’s compiles of the language (every object of a target shares the same per-package prefix the check filter tests).

Implementations

impl StandardViolation

pub fn object(&self) -> &Utf8PathBuf

Object path of the offending compile, for the check rewrite’s path filter.

Trait Implementations

impl Clone for StandardViolation

fn clone(&self) -> StandardViolation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StandardViolation

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

Formats the value using the given formatter.

impl Eq for StandardViolation

impl PartialEq for StandardViolation

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for StandardViolation