Enum Unsupported 

#[non_exhaustive]
pub enum Unsupported {
    Class,
    Record,
    Reference,
    RefPlace,
    VarVar,
    Intrinsic,
    Asm,
    BigInt,
    ForeignUnit,
    TypeDirected,
    ExternValue,
    ExternArgs,
    Conversion,
    Cast,
    Pattern,
    Impl,
    MultipleInheritance,
    ClassValue,
    MixinMember,
    ClassTest,
    AmbiguousClass,
    StaticRef,
}

A HIR form this release does not compile, named precisely.

Every variant says what is missing and where it is planned, so a front end can report “not supported yet” instead of guessing. Forms that need a missing LSB feature (not a later bcgen-lang release) say so.

Examples

use bcgen_lang::Unsupported;

assert!(Unsupported::Impl.to_string().contains("impl"));

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.

Class

A receiver parameter outside a member of a class or mixin (a closure or a free function cannot take one).

Record

A record or struct literal or pattern naming a declared type, a sum variant, or a constructor pattern (typed data arrives with classes in 0.5; anonymous records compile, as maps).

Reference

*e, &e, a ref pattern, or binding by reference: the dynamic profile has no pointer values (PHP references are places, see RefPlace).

RefPlace

A reference (&) to a place LSB cannot reference: an appended element (&$a[], whose key is known only after the append), a variable variable, or a value that is not a place.

VarVar

$$name: LSB frames have no names at run time.

Intrinsic

An atomic, volatile, or fence intrinsic (native backends only; named intrinsics compile through the Intrinsics table).

Asm

Inline assembly (native backends only).

BigInt

A big-integer literal (no big-integer runtime yet).

ForeignUnit

A definition of another compilation unit: LSB modules link to host functions only, so cross-unit calls wait for loader-lang.

TypeDirected

A path resolved only by type (Vec::new), or naming a primitive, type parameter, or const parameter as a value (typed paths, 0.5).

ExternValue

A host function used as a value rather than called: the compiler does not know the host function’s parameter list, which a first-class value needs (LSB §5.15).

ExternArgs

Spread or named arguments to a host function: the compiler does not know its parameter names, so imports take exactly their positional parameters.

Conversion

A conversion at a width dynamic values do not have (zext/sext to fewer than 64 bits, 32-bit bit casts).

Cast

A cast to a type the dynamic profile cannot test or produce.

Pattern

A range pattern bound or type test this release cannot evaluate.

Impl

An impl block (methods of a static language’s type): typed fast paths, 0.5.

MultipleInheritance

A class with more than one base (Python): an LSB struct has one parent (LSB §3.1).

ClassValue

A class, interface, or mixin name used as a value outside new, instanceof, a type test, and member access (Foo::class and class values are the lowering’s job).

MixinMember

A member reached through a mixin (PHP trait) itself, T::m(): only the classes that use the mixin have its members (PHP 8.1 deprecates calling a trait’s static members directly).

ClassTest

A type test (catch, instanceof by type) against a class or interface the unit does not declare: its struct type is not in the module.

AmbiguousClass

A static member path (C::m) whose class the compiler cannot pick: the unit declares two classes of that name that both reach the member.

StaticRef

Binding a late-bound static property to a reference (static::$x = &$y): the reference lives in a global the accessor only reads.

Implementations

impl Unsupported

pub const fn describe(self) -> &'static str

A short description of the form and where it is planned.

Examples

use bcgen_lang::Unsupported;

assert_eq!(Unsupported::Asm.describe(), "inline assembly (native backends only)");

Trait Implementations

impl Clone for Unsupported

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Unsupported

impl Debug for Unsupported

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

Formats the value using the given formatter.

impl Display for Unsupported

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

Formats the value using the given formatter.

impl Eq for Unsupported

impl Hash for Unsupported

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

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 PartialEq for Unsupported

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Unsupported