Enum Case 

#[non_exhaustive]
pub enum Case {
    Sensitive,
    AsciiInsensitive,
}

How a namespace’s table compares names.

Folding is a property of the table: every name stored in it, and every name looked up in it, is compared through the same fold. Folding is deterministic and independent of locale; diagnostics, the index, and ClassMember keep each name as it was written.

Only ASCII folding is offered: it is what PHP 8 does for function, class, interface, trait, enum, and namespace names (bytes A-Z match a-z; every other byte, including UTF-8 sequences, must match exactly). Unicode case folding is not provided: no target language needs it, and its tables change with the Unicode version, which would make resolution depend on the toolchain.

Examples

use resolve_lang::{Case, Namespace, Policy};

assert_eq!(Policy::php().case(Namespace::Value), Case::AsciiInsensitive);
assert_eq!(Policy::php().case(Namespace::Const), Case::Sensitive);
assert_eq!(Policy::python().case(Namespace::Value), Case::Sensitive);

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.

Sensitive

Names match only when spelled identically (the default everywhere).

AsciiInsensitive

Names match when they are equal after mapping ASCII A-Z to a-z (PHP 8).

Trait Implementations

impl Clone for Case

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 Case

impl Debug for Case

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

Formats the value using the given formatter.

impl Eq for Case

impl Hash for Case

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 Case

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Case