Enum CompilerStage 

#[non_exhaustive]
pub enum CompilerStage {
    Parsing,
    Lowering,
    Analysis,
}

Compiler stage.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Parsing

Source code parsing.

Includes lexing, parsing to ASTs, import resolution which recursively parses imported files.

Lowering

ASTs lowering to HIR.

Includes lowering all ASTs to a single HIR, inheritance resolution, name resolution, basic type checking.

Analysis

Analysis.

Includes type checking, computing ABI, static analysis.

Implementations

impl CompilerStage

pub const fn is_parsing(&self) -> bool

Returns true if the enum is CompilerStage::Parsing otherwise false

pub const fn is_lowering(&self) -> bool

Returns true if the enum is CompilerStage::Lowering otherwise false

pub const fn is_analysis(&self) -> bool

Returns true if the enum is CompilerStage::Analysis otherwise false

impl CompilerStage

pub const fn from_repr(discriminant: usize) -> Option<CompilerStage>

Try to create Self from the raw representation

impl CompilerStage

pub fn to_str(self) -> &'static str

Returns the string representation of self.

impl CompilerStage

pub fn next(self) -> Option<CompilerStage>

Returns the next stage, or None if this is the last stage.

pub fn next_opt(this: Option<CompilerStage>) -> Option<CompilerStage>

Returns the next stage, None if this is the last stage or the first stage if None is passed.

Trait Implementations

impl Clone for CompilerStage

fn clone(&self) -> CompilerStage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompilerStage

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

Formats the value using the given formatter.

impl Display for CompilerStage

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

Formats the value using the given formatter.

impl EnumCount for CompilerStage

const COUNT: usize = 3usize

impl<'_derivative_strum> From<&'_derivative_strum CompilerStage> for &'static str

fn from(x: &'_derivative_strum CompilerStage) -> &'static str

Converts to this type from the input type.

impl From<CompilerStage> for &'static str

fn from(x: CompilerStage) -> &'static str

Converts to this type from the input type.

impl FromStr for CompilerStage

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<CompilerStage, <CompilerStage as FromStr>::Err>

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

impl Hash for CompilerStage

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoEnumIterator for CompilerStage

type Iterator = CompilerStageIter

fn iter() -> CompilerStageIter

impl Ord for CompilerStage

fn cmp(&self, other: &CompilerStage) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for CompilerStage

fn eq(&self, other: &CompilerStage) -> 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 PartialOrd for CompilerStage

fn partial_cmp(&self, other: &CompilerStage) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<&str> for CompilerStage

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from( s: &str, ) -> Result<CompilerStage, <CompilerStage as TryFrom<&str>>::Error>

Performs the conversion.

impl ValueEnum for CompilerStage

fn value_variants<'a>() -> &'a [CompilerStage]

All possible argument values, in display order.

fn to_possible_value(&self) -> Option<PossibleValue>

The canonical argument value.

fn from_str(input: &str, ignore_case: bool) -> Result<Self, String>

Parse an argument into Self.

impl VariantNames for CompilerStage

const VARIANTS: &'static [&'static str]

Names of the variants of this enum

impl Copy for CompilerStage

impl Eq for CompilerStage

impl StructuralPartialEq for CompilerStage