use serde::{Deserialize, Serialize};
pub const CAIXA_THEME_SEMANTIC_WIRE_KEYWORD: &str = "keyword";
pub const CAIXA_THEME_SEMANTIC_WIRE_SYMBOL: &str = "symbol";
pub const CAIXA_THEME_SEMANTIC_WIRE_KEYWORD_ARG: &str = "keyword-arg";
pub const CAIXA_THEME_SEMANTIC_WIRE_STRING: &str = "string";
pub const CAIXA_THEME_SEMANTIC_WIRE_NUMBER: &str = "number";
pub const CAIXA_THEME_SEMANTIC_WIRE_LITERAL: &str = "literal";
pub const CAIXA_THEME_SEMANTIC_WIRE_COMMENT: &str = "comment";
pub const CAIXA_THEME_SEMANTIC_WIRE_ACCENT: &str = "accent";
pub const CAIXA_THEME_SEMANTIC_WIRE_MUTED: &str = "muted";
pub const CAIXA_THEME_SEMANTIC_WIRE_ERROR: &str = "error";
pub const CAIXA_THEME_SEMANTIC_WIRE_WARNING: &str = "warning";
pub const CAIXA_THEME_SEMANTIC_WIRE_INFO: &str = "info";
pub const CAIXA_THEME_SEMANTIC_WIRE_HINT: &str = "hint";
pub const CAIXA_THEME_SEMANTIC_WIRE_ADDED: &str = "added";
pub const CAIXA_THEME_SEMANTIC_WIRE_REMOVED: &str = "removed";
pub const CAIXA_THEME_SEMANTIC_WIRE_UNCHANGED: &str = "unchanged";
#[derive(
Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, gen_platform::IsVariant,
)]
pub enum Semantic {
Keyword,
Symbol,
KeywordArg,
String,
Number,
Literal,
Comment,
Accent,
Muted,
Error,
Warning,
Info,
Hint,
Added,
Removed,
Unchanged,
}
impl Semantic {
pub const ALL: &'static [Self] = &[
Self::Keyword,
Self::Symbol,
Self::KeywordArg,
Self::String,
Self::Number,
Self::Literal,
Self::Comment,
Self::Accent,
Self::Muted,
Self::Error,
Self::Warning,
Self::Info,
Self::Hint,
Self::Added,
Self::Removed,
Self::Unchanged,
];
pub const WIRE_NAMES: &'static [&'static str] = &[
CAIXA_THEME_SEMANTIC_WIRE_KEYWORD,
CAIXA_THEME_SEMANTIC_WIRE_SYMBOL,
CAIXA_THEME_SEMANTIC_WIRE_KEYWORD_ARG,
CAIXA_THEME_SEMANTIC_WIRE_STRING,
CAIXA_THEME_SEMANTIC_WIRE_NUMBER,
CAIXA_THEME_SEMANTIC_WIRE_LITERAL,
CAIXA_THEME_SEMANTIC_WIRE_COMMENT,
CAIXA_THEME_SEMANTIC_WIRE_ACCENT,
CAIXA_THEME_SEMANTIC_WIRE_MUTED,
CAIXA_THEME_SEMANTIC_WIRE_ERROR,
CAIXA_THEME_SEMANTIC_WIRE_WARNING,
CAIXA_THEME_SEMANTIC_WIRE_INFO,
CAIXA_THEME_SEMANTIC_WIRE_HINT,
CAIXA_THEME_SEMANTIC_WIRE_ADDED,
CAIXA_THEME_SEMANTIC_WIRE_REMOVED,
CAIXA_THEME_SEMANTIC_WIRE_UNCHANGED,
];
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Keyword => CAIXA_THEME_SEMANTIC_WIRE_KEYWORD,
Self::Symbol => CAIXA_THEME_SEMANTIC_WIRE_SYMBOL,
Self::KeywordArg => CAIXA_THEME_SEMANTIC_WIRE_KEYWORD_ARG,
Self::String => CAIXA_THEME_SEMANTIC_WIRE_STRING,
Self::Number => CAIXA_THEME_SEMANTIC_WIRE_NUMBER,
Self::Literal => CAIXA_THEME_SEMANTIC_WIRE_LITERAL,
Self::Comment => CAIXA_THEME_SEMANTIC_WIRE_COMMENT,
Self::Accent => CAIXA_THEME_SEMANTIC_WIRE_ACCENT,
Self::Muted => CAIXA_THEME_SEMANTIC_WIRE_MUTED,
Self::Error => CAIXA_THEME_SEMANTIC_WIRE_ERROR,
Self::Warning => CAIXA_THEME_SEMANTIC_WIRE_WARNING,
Self::Info => CAIXA_THEME_SEMANTIC_WIRE_INFO,
Self::Hint => CAIXA_THEME_SEMANTIC_WIRE_HINT,
Self::Added => CAIXA_THEME_SEMANTIC_WIRE_ADDED,
Self::Removed => CAIXA_THEME_SEMANTIC_WIRE_REMOVED,
Self::Unchanged => CAIXA_THEME_SEMANTIC_WIRE_UNCHANGED,
}
}
#[must_use]
pub fn from_wire(s: &str) -> Option<Self> {
match s {
CAIXA_THEME_SEMANTIC_WIRE_KEYWORD => Some(Self::Keyword),
CAIXA_THEME_SEMANTIC_WIRE_SYMBOL => Some(Self::Symbol),
CAIXA_THEME_SEMANTIC_WIRE_KEYWORD_ARG => Some(Self::KeywordArg),
CAIXA_THEME_SEMANTIC_WIRE_STRING => Some(Self::String),
CAIXA_THEME_SEMANTIC_WIRE_NUMBER => Some(Self::Number),
CAIXA_THEME_SEMANTIC_WIRE_LITERAL => Some(Self::Literal),
CAIXA_THEME_SEMANTIC_WIRE_COMMENT => Some(Self::Comment),
CAIXA_THEME_SEMANTIC_WIRE_ACCENT => Some(Self::Accent),
CAIXA_THEME_SEMANTIC_WIRE_MUTED => Some(Self::Muted),
CAIXA_THEME_SEMANTIC_WIRE_ERROR => Some(Self::Error),
CAIXA_THEME_SEMANTIC_WIRE_WARNING => Some(Self::Warning),
CAIXA_THEME_SEMANTIC_WIRE_INFO => Some(Self::Info),
CAIXA_THEME_SEMANTIC_WIRE_HINT => Some(Self::Hint),
CAIXA_THEME_SEMANTIC_WIRE_ADDED => Some(Self::Added),
CAIXA_THEME_SEMANTIC_WIRE_REMOVED => Some(Self::Removed),
CAIXA_THEME_SEMANTIC_WIRE_UNCHANGED => Some(Self::Unchanged),
_ => None,
}
}
}
impl std::fmt::Display for Semantic {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for Semantic {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl TryFrom<&str> for Semantic {
type Error = ();
fn try_from(s: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
Self::from_wire(s).ok_or(())
}
}
impl std::str::FromStr for Semantic {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
<Self as TryFrom<&str>>::try_from(s)
}
}
impl From<Semantic> for &'static str {
fn from(sem: Semantic) -> &'static str {
sem.as_str()
}
}
impl From<&Semantic> for &'static str {
fn from(sem: &Semantic) -> &'static str {
sem.as_str()
}
}
impl From<Semantic> for String {
fn from(sem: Semantic) -> String {
sem.as_str().to_owned()
}
}
impl From<&Semantic> for String {
fn from(sem: &Semantic) -> String {
sem.as_str().to_owned()
}
}
impl From<Semantic> for std::borrow::Cow<'static, str> {
fn from(sem: Semantic) -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed(sem.as_str())
}
}
impl From<&Semantic> for std::borrow::Cow<'static, str> {
fn from(sem: &Semantic) -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed(sem.as_str())
}
}
impl From<Semantic> for Box<str> {
fn from(sem: Semantic) -> Box<str> {
Box::<str>::from(sem.as_str())
}
}
impl From<&Semantic> for Box<str> {
fn from(sem: &Semantic) -> Box<str> {
Box::<str>::from(sem.as_str())
}
}
impl From<Semantic> for std::sync::Arc<str> {
fn from(sem: Semantic) -> std::sync::Arc<str> {
std::sync::Arc::<str>::from(sem.as_str())
}
}
impl From<&Semantic> for std::sync::Arc<str> {
fn from(sem: &Semantic) -> std::sync::Arc<str> {
std::sync::Arc::<str>::from(sem.as_str())
}
}
impl From<Semantic> for std::rc::Rc<str> {
fn from(sem: Semantic) -> std::rc::Rc<str> {
std::rc::Rc::<str>::from(sem.as_str())
}
}
impl From<&Semantic> for std::rc::Rc<str> {
fn from(sem: &Semantic) -> std::rc::Rc<str> {
std::rc::Rc::<str>::from(sem.as_str())
}
}
impl AsRef<[u8]> for Semantic {
fn as_ref(&self) -> &[u8] {
self.as_str().as_bytes()
}
}
impl From<Semantic> for Vec<u8> {
fn from(semantic: Semantic) -> Vec<u8> {
semantic.as_str().as_bytes().to_vec()
}
}
impl From<&Semantic> for Vec<u8> {
fn from(semantic: &Semantic) -> Vec<u8> {
semantic.as_str().as_bytes().to_vec()
}
}
impl TryFrom<&[u8]> for Semantic {
type Error = ();
fn try_from(bytes: &[u8]) -> Result<Self, <Self as TryFrom<&[u8]>>::Error> {
std::str::from_utf8(bytes)
.ok()
.and_then(Self::from_wire)
.ok_or(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn semantic_all_enumerates_every_variant_in_declaration_order() {
assert_eq!(
Semantic::ALL,
&[
Semantic::Keyword,
Semantic::Symbol,
Semantic::KeywordArg,
Semantic::String,
Semantic::Number,
Semantic::Literal,
Semantic::Comment,
Semantic::Accent,
Semantic::Muted,
Semantic::Error,
Semantic::Warning,
Semantic::Info,
Semantic::Hint,
Semantic::Added,
Semantic::Removed,
Semantic::Unchanged,
],
);
for variant in Semantic::ALL {
let row = [
variant.is_keyword(),
variant.is_symbol(),
variant.is_keyword_arg(),
variant.is_string(),
variant.is_number(),
variant.is_literal(),
variant.is_comment(),
variant.is_accent(),
variant.is_muted(),
variant.is_error(),
variant.is_warning(),
variant.is_info(),
variant.is_hint(),
variant.is_added(),
variant.is_removed(),
variant.is_unchanged(),
];
let hits = row.iter().filter(|b| **b).count();
assert_eq!(
hits, 1,
"Semantic::{variant:?} must satisfy exactly one of the \
15 is_* arm-discriminator predicates; got {row:?}",
);
}
}
#[test]
fn semantic_is_variant_predicates_partition_the_arm_set() {
for (idx, variant) in Semantic::ALL.iter().enumerate() {
let observed: [bool; 16] = [
variant.is_keyword(),
variant.is_symbol(),
variant.is_keyword_arg(),
variant.is_string(),
variant.is_number(),
variant.is_literal(),
variant.is_comment(),
variant.is_accent(),
variant.is_muted(),
variant.is_error(),
variant.is_warning(),
variant.is_info(),
variant.is_hint(),
variant.is_added(),
variant.is_removed(),
variant.is_unchanged(),
];
let mut expected = [false; 16];
expected[idx] = true;
assert_eq!(
observed, expected,
"Semantic::{variant:?} at ALL[{idx}] is_* predicates \
must fire only on their own arm lane (identity \
diagonal); got {observed:?}",
);
}
}
#[test]
fn semantic_as_str_returns_canonical_kebab_case_per_arm() {
assert_eq!(Semantic::Keyword.as_str(), "keyword");
assert_eq!(Semantic::Symbol.as_str(), "symbol");
assert_eq!(Semantic::KeywordArg.as_str(), "keyword-arg");
assert_eq!(Semantic::String.as_str(), "string");
assert_eq!(Semantic::Number.as_str(), "number");
assert_eq!(Semantic::Literal.as_str(), "literal");
assert_eq!(Semantic::Comment.as_str(), "comment");
assert_eq!(Semantic::Accent.as_str(), "accent");
assert_eq!(Semantic::Muted.as_str(), "muted");
assert_eq!(Semantic::Error.as_str(), "error");
assert_eq!(Semantic::Warning.as_str(), "warning");
assert_eq!(Semantic::Info.as_str(), "info");
assert_eq!(Semantic::Hint.as_str(), "hint");
assert_eq!(Semantic::Added.as_str(), "added");
assert_eq!(Semantic::Removed.as_str(), "removed");
assert_eq!(Semantic::Unchanged.as_str(), "unchanged");
}
#[test]
fn semantic_as_str_projections_are_all_distinct_across_arms() {
let mut projections: Vec<&'static str> = Semantic::ALL.iter().map(|s| s.as_str()).collect();
let before = projections.len();
projections.sort_unstable();
projections.dedup();
assert_eq!(
projections.len(),
before,
"Semantic::as_str must be injective across ALL — collisions: \
{projections:?}",
);
}
#[test]
fn semantic_display_and_as_ref_str_route_through_as_str_accessor() {
for &sem in Semantic::ALL {
let via_as_str: &str = sem.as_str();
let via_display: String = format!("{sem}");
let via_as_ref: &str = <Semantic as AsRef<str>>::as_ref(&sem);
assert_eq!(
via_display, via_as_str,
"Semantic::{sem:?} — Display routes off `as_str`; got \
Display={via_display:?} vs as_str={via_as_str:?}",
);
assert_eq!(
via_as_ref, via_as_str,
"Semantic::{sem:?} — AsRef<str> routes off `as_str`; got \
AsRef={via_as_ref:?} vs as_str={via_as_str:?}",
);
}
}
#[test]
fn semantic_as_str_is_usable_in_const_context() {
const KEYWORD: &str = Semantic::Keyword.as_str();
const ERROR: &str = Semantic::Error.as_str();
const UNCHANGED: &str = Semantic::Unchanged.as_str();
const { assert!(KEYWORD.as_bytes()[0] == b'k') };
const { assert!(ERROR.as_bytes()[0] == b'e') };
const { assert!(UNCHANGED.as_bytes()[0] == b'u') };
}
#[test]
fn semantic_from_wire_accepts_every_as_str_output() {
for &variant in Semantic::ALL {
let wire = variant.as_str();
let parsed = Semantic::from_wire(wire).unwrap_or_else(|| {
panic!(
"Semantic::from_wire({wire:?}) must accept every \
Semantic::as_str output — got None for the wire \
byte-string of {variant:?}"
)
});
assert_eq!(
parsed, variant,
"Semantic::from_wire(Semantic::{variant:?}.as_str()) \
must return Semantic::{variant:?} — the (as_str, \
from_wire) pair must form a total round-trip on the \
closed 16-arm Semantic arm-set",
);
}
}
#[test]
fn semantic_from_wire_rejects_unknown_byte_strings() {
for bad in [
"",
" ",
"Keyword",
"KEYWORD",
"Symbol",
"SYMBOL",
"KeywordArg",
"keyword_arg",
"keywordarg",
"String",
"STRING",
"Number",
"Literal",
"Comment",
"Accent",
"Muted",
"Error",
"ERROR",
"Warning",
"WARNING",
"Info",
"INFO",
"Hint",
"HINT",
"Added",
"ADDED",
"Removed",
"REMOVED",
"Unchanged",
"UNCHANGED",
"kewyord",
"sym",
"kw",
"str",
"num",
"lit",
"cmt",
"safe",
"unsafe",
"safety",
"compliance",
"proven",
"rejected",
"namespace",
"deleted",
"highlight",
"identifier",
"keyword ",
" keyword",
"keyword\n",
"keyword\t",
"keyword-arg ",
" keyword-arg",
"added ",
" added",
"unchanged ",
" unchanged",
] {
assert!(
Semantic::from_wire(bad).is_none(),
"Semantic::from_wire({bad:?}) must return None — the \
parser's accept-set is exactly the 16 Semantic::as_str \
outputs; a widening would silently split the parser's \
accept-set from the emitter's arm-set",
);
}
}
#[test]
fn semantic_is_variant_predicates_are_const_fn() {
const { assert!(Semantic::Keyword.is_keyword()) };
const { assert!(Semantic::Error.is_error()) };
const { assert!(Semantic::Added.is_added()) };
const { assert!(Semantic::Unchanged.is_unchanged()) };
}
#[test]
fn semantic_try_from_str_routes_through_from_wire_accessor() {
for &variant in Semantic::ALL {
let wire = variant.as_str();
assert_eq!(
<Semantic as TryFrom<&str>>::try_from(wire),
Ok(variant),
"TryFrom<&str> impl on Semantic must round-trip \
Semantic::{variant:?}.as_str() = {wire:?} back to \
Ok(Semantic::{variant:?}) — divergence from \
Semantic::from_wire signals a silent detour off the \
substrate-primitive accessor",
);
assert_eq!(
<Semantic as TryFrom<&str>>::try_from(wire).ok(),
Semantic::from_wire(wire),
"TryFrom<&str> ok()-projection on {wire:?} must \
byte-equal Semantic::from_wire on the same input",
);
}
}
#[test]
fn semantic_try_from_str_rejects_unknown_byte_strings() {
for bad in [
"",
" ",
"Keyword",
"KEYWORD",
"Symbol",
"KeywordArg",
"keywordarg",
"keyword_arg",
"keyword.arg",
"String",
"Number",
"Literal",
"Comment",
"Accent",
"Muted",
"Error",
"ERROR",
"Warning",
"Info",
"Hint",
"Added",
"Removed",
"Unchanged",
"kwd",
"sym",
"kw",
"str",
"num",
"lit",
"cmt",
"safe",
"unsafe",
"safety",
"compliance",
"proven",
"rejected",
"namespace",
"deleted",
"highlight",
"identifier",
"keyword ",
" keyword",
"keyword\n",
"keyword\t",
"keyword-arg ",
" keyword-arg",
"added ",
" added",
"unchanged ",
" unchanged",
] {
assert_eq!(
<Semantic as TryFrom<&str>>::try_from(bad),
Err(()),
"TryFrom<&str> for Semantic({bad:?}) must return \
Err(()) — the trait impl's accept-set is exactly the \
16 Semantic::as_str outputs; a widening would \
silently split the trait impl's accept-set from the \
emitter's arm-set",
);
}
}
#[test]
fn semantic_try_from_str_and_from_wire_partition_the_accept_set() {
for &variant in Semantic::ALL {
let wire = variant.as_str();
assert_eq!(
<Semantic as TryFrom<&str>>::try_from(wire).ok(),
Semantic::from_wire(wire),
"TryFrom<&str>::ok() and from_wire must agree on \
Semantic::{variant:?}.as_str() = {wire:?}",
);
}
for bad in [
"",
"Keyword",
"unknown",
"safety",
"safe",
"proven",
"namespace",
"keywordarg",
] {
assert_eq!(
<Semantic as TryFrom<&str>>::try_from(bad).ok(),
Semantic::from_wire(bad),
"TryFrom<&str>::ok() and from_wire must agree on the \
rejection outcome for {bad:?}",
);
}
}
#[test]
fn semantic_from_str_routes_through_try_from_str_impl() {
use std::str::FromStr;
for &variant in Semantic::ALL {
let wire = variant.as_str();
assert_eq!(
<Semantic as FromStr>::from_str(wire),
Ok(variant),
"FromStr impl on Semantic must round-trip \
Semantic::{variant:?}.as_str() = {wire:?} back to \
Ok(Semantic::{variant:?}) — divergence from the paired \
TryFrom<&str> impl / Semantic::from_wire signals a \
silent detour off the substrate-primitive accessor",
);
assert_eq!(
wire.parse::<Semantic>(),
Ok(variant),
"stdlib .parse::<Semantic>() short-form on \
Semantic::{variant:?}.as_str() = {wire:?} must route \
through the lifted FromStr impl and reach \
Ok(Semantic::{variant:?})",
);
assert_eq!(
<Semantic as FromStr>::from_str(wire).ok(),
Semantic::from_wire(wire),
"FromStr::from_str ok()-projection on {wire:?} must \
byte-equal Semantic::from_wire on the same input — \
the two reverse-projection axes must resolve to the \
same 16-arm canonical-lowercase-kebab accept-set",
);
assert_eq!(
<Semantic as FromStr>::from_str(wire),
<Semantic as TryFrom<&str>>::try_from(wire),
"FromStr::from_str and TryFrom<&str>::try_from must \
byte-equal on every arm — FromStr delegates to \
TryFrom<&str> by construction; divergence signals a \
stray reroute onto a hand-rolled parser",
);
}
}
#[test]
fn semantic_from_str_rejects_unknown_byte_strings() {
use std::str::FromStr;
for bad in [
"",
" ",
"\t",
"\n",
"Keyword",
"KEYWORD",
"KeywordArg",
"keyword_arg",
"keyword arg",
"keywordarg",
"keywor",
"Symbol",
"SYMBOL",
"Comment",
"unknown",
"biblioteca",
"servico",
"safety",
"compliance",
"performance",
"proven",
"rejected",
"safe",
"unsafe",
"one-for-one",
"empty",
"absolute",
"parent-escape",
"keyword ",
" keyword",
"keyword\n",
"keyword\t",
"\"keyword\"",
] {
assert_eq!(
<Semantic as FromStr>::from_str(bad),
Err(()),
"FromStr for Semantic({bad:?}) must return Err(()) — \
the trait impl's accept-set is exactly the 16 \
Semantic::as_str outputs; a widening would silently \
split the FromStr impl's accept-set from the \
emitter's arm-set",
);
assert_eq!(
bad.parse::<Semantic>(),
Err(()),
"stdlib .parse::<Semantic>() short-form on {bad:?} \
must route through the lifted FromStr impl and \
reject with Err(())",
);
}
}
#[test]
fn semantic_from_into_static_str_routes_through_as_str_accessor() {
const KEYWORD: &str = Semantic::Keyword.as_str();
const KEYWORD_ARG: &str = Semantic::KeywordArg.as_str();
const UNCHANGED: &str = Semantic::Unchanged.as_str();
for &variant in Semantic::ALL {
let via_trait: &'static str = <&'static str as From<Semantic>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait, via_method,
"From<Semantic> for &'static str impl must round-trip \
Semantic::{variant:?} to the same canonical-lowercase \
kebab byte-string Semantic::as_str returns — divergence \
signals a silent detour off the substrate-primitive \
accessor"
);
let via_into: &'static str = variant.into();
assert_eq!(
via_into, via_method,
"Into<&'static str>::into on Semantic::{variant:?} must \
byte-equal Semantic::as_str on the same input — the \
blanket-derived Into shape must resolve to the same \
as_str dispatch as the explicit From impl"
);
}
assert_eq!(
[KEYWORD, KEYWORD_ARG, UNCHANGED],
["keyword", "keyword-arg", "unchanged"],
"const-context Semantic::as_str must resolve to the \
canonical-lowercase kebab byte-strings — a future \
accidental downgrade of any arm to a non-const or non-\
static byte-string breaks the `&'static str`-lifetime \
promise the paired From<Semantic> for &'static str impl \
carries by construction"
);
}
#[test]
fn semantic_from_into_static_str_and_as_str_partition_the_emit_set() {
for &variant in Semantic::ALL {
let via_trait: &'static str = <&'static str as From<Semantic>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait, via_method,
"From<Semantic> for &'static str and Semantic::as_str \
must resolve identically on Semantic::{variant:?} — \
divergence signals the two forward-projection paths \
have drifted onto different emit-sets"
);
}
for &variant in Semantic::ALL {
let emitted: &'static str = <&'static str as From<Semantic>>::from(variant);
let reparsed = <Semantic as TryFrom<&str>>::try_from(emitted).unwrap_or_else(|()| {
panic!(
"TryFrom<&str> for Semantic must accept every \
From<Semantic> for &'static str output — got \
Err(()) for Semantic::{variant:?}'s emit \
byte-string {emitted:?}"
)
});
assert_eq!(
reparsed, variant,
"trait-idiomatic Semantic ↔ &'static str round-trip \
must be the identity on Semantic::{variant:?} — the \
From<Self> for &'static str + TryFrom<&str> for Self \
pair must compose to the identity on the closed 16-arm \
accept-set"
);
}
}
#[test]
fn semantic_from_borrowed_into_static_str_routes_through_as_str_accessor() {
const KEYWORD: &str = Semantic::Keyword.as_str();
const KEYWORD_ARG: &str = Semantic::KeywordArg.as_str();
const UNCHANGED: &str = Semantic::Unchanged.as_str();
for variant in Semantic::ALL {
let via_trait: &'static str = <&'static str as From<&Semantic>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait, via_method,
"From<&Semantic> for &'static str impl must round-trip \
&Semantic::{variant:?} to the same canonical-lowercase \
kebab byte-string Semantic::as_str returns — divergence \
signals a silent detour off the substrate-primitive \
accessor"
);
let via_into: &'static str = variant.into();
assert_eq!(
via_into, via_method,
"Into<&'static str>::into on &Semantic::{variant:?} must \
byte-equal Semantic::as_str on the same input — the \
blanket-derived Into shape on the borrowed-input axis \
must resolve to the same as_str dispatch as the \
explicit From impl"
);
}
assert_eq!(
[KEYWORD, KEYWORD_ARG, UNCHANGED],
["keyword", "keyword-arg", "unchanged"],
"const-context Semantic::as_str must resolve to the \
canonical-lowercase kebab byte-strings — a future \
accidental downgrade of any arm to a non-const or non-\
static byte-string breaks the `&'static str`-lifetime \
promise the paired From<&Semantic> for &'static str impl \
carries by construction"
);
}
#[test]
fn semantic_from_owned_and_borrowed_into_static_str_agree_on_every_arm() {
for &variant in Semantic::ALL {
let via_owned: &'static str = <&'static str as From<Semantic>>::from(variant);
let via_borrowed: &'static str = <&'static str as From<&Semantic>>::from(&variant);
assert_eq!(
via_owned, via_borrowed,
"From<Semantic> for &'static str and From<&Semantic> \
for &'static str must agree on Semantic::{variant:?} \
— divergence signals the owned-input and borrowed-\
input forward-projection paths have drifted onto \
different emit-sets"
);
}
let via_pipe: Vec<&'static str> = Semantic::ALL.iter().map(Into::into).collect();
let via_method: Vec<&'static str> = Semantic::ALL.iter().map(|s| s.as_str()).collect();
assert_eq!(
via_pipe, via_method,
"Semantic::ALL.iter().map(Into::into) must resolve to the \
same per-arm canonical-lowercase kebab byte-string \
sequence Semantic::as_str returns across every arm — the \
iterator yields &Semantic, so this pipe fires through the \
borrowed-input From<&Semantic> for &'static str axis and \
witnesses the newly lifted impl's arm-set matches the \
substrate-primitive accessor without a spurious Copy deref"
);
}
#[test]
fn semantic_from_into_owned_string_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: String = <String as From<Semantic>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_str(),
via_method,
"From<Semantic> for String impl must round-trip \
Semantic::{variant:?} to the same canonical-lowercase \
kebab byte-string Semantic::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: String = variant.into();
assert_eq!(
via_into.as_str(),
via_method,
"Into<String>::into on Semantic::{variant:?} must \
byte-equal Semantic::as_str on the same input — the \
blanket-derived Into shape must resolve to the same \
as_str dispatch as the explicit From impl"
);
}
}
#[test]
fn semantic_from_into_owned_string_and_static_str_agree_on_every_arm() {
for &variant in Semantic::ALL {
let owned_string: String = <String as From<Semantic>>::from(variant);
let owned_static: &'static str = <&'static str as From<Semantic>>::from(variant);
assert_eq!(
owned_string.as_str(),
owned_static,
"From<Semantic> for String and From<Semantic> for \
&'static str must resolve identically on \
Semantic::{variant:?} — divergence signals the two \
output-shape forward-projection paths have drifted \
onto different emit-sets"
);
let via_display: String = variant.to_string();
assert_eq!(
owned_string, via_display,
"From<Semantic> for String and ToString::to_string \
via Display must resolve identically on \
Semantic::{variant:?} — divergence signals the \
trait-idiomatic owned-`String` axis and the Display-\
routed ToString axis have drifted onto different \
vocabularies"
);
}
let via_iter: Vec<String> = Semantic::ALL.iter().copied().map(String::from).collect();
let via_method: Vec<String> = Semantic::ALL
.iter()
.map(|s| s.as_str().to_owned())
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().copied().map(String::from)` over Semantic::ALL \
must byte-equal `.iter().map(|s| s.as_str().to_owned())` \
on every arm — the owned-`String` `From<Semantic> for \
String` axis is what makes the `.map(String::from)` \
shape route through the substrate-primitive \
Semantic::as_str accessor rather than through a per-\
call-site `.to_owned()` / `String::from(sem.as_str())` \
detour"
);
for &variant in Semantic::ALL {
let emitted: String = variant.into();
let re_parsed: Result<Semantic, ()> =
<Semantic as TryFrom<&str>>::try_from(emitted.as_str());
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic owned-`String` axis pair must round-\
trip Semantic::{variant:?} through \
`.into::<String>()` and back through `TryFrom<&str>` \
on the owned-`String`'s `String::as_str` borrow — a \
break signals the forward-emit owned-`String` axis \
and the reverse-parse `TryFrom<&str>` axis have \
drifted onto different vocabularies"
);
}
}
#[test]
fn semantic_from_borrowed_into_owned_string_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: String = <String as From<&Semantic>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_str(),
via_method,
"From<&Semantic> for String impl must round-trip \
&Semantic::{variant:?} to the same canonical-\
lowercase kebab byte-string Semantic::as_str \
returns — divergence signals a silent detour off \
the substrate-primitive accessor"
);
let via_into: String = (&variant).into();
assert_eq!(
via_into.as_str(),
via_method,
"Into<String>::into on &Semantic::{variant:?} must \
byte-equal Semantic::as_str on the same input — \
the blanket-derived Into shape must resolve to the \
same as_str dispatch as the explicit From impl"
);
}
}
#[test]
fn semantic_from_borrowed_into_owned_string_agrees_with_paired_axes_on_every_arm() {
for &variant in Semantic::ALL {
let borrowed_string: String = <String as From<&Semantic>>::from(&variant);
let owned_string: String = <String as From<Semantic>>::from(variant);
let borrowed_static: &'static str = <&'static str as From<&Semantic>>::from(&variant);
let owned_static: &'static str = <&'static str as From<Semantic>>::from(variant);
assert_eq!(
borrowed_string, owned_string,
"From<&Semantic> for String and From<Semantic> for \
String must resolve identically on \
Semantic::{variant:?} — divergence signals the \
owned-`String` axis pair's borrowed-input and \
owned-input arms have drifted onto different emit-\
sets"
);
assert_eq!(
borrowed_string.as_str(),
borrowed_static,
"From<&Semantic> for String and From<&Semantic> for \
&'static str must resolve identically on \
Semantic::{variant:?} — divergence signals the \
borrowed-input axis pair's owned-`String`-returning \
and `&'static str`-returning arms have drifted \
onto different emit-sets"
);
assert_eq!(
borrowed_string.as_str(),
owned_static,
"From<&Semantic> for String and From<Semantic> for \
&'static str must resolve identically on \
Semantic::{variant:?} — the cross-diagonal corner \
of the 2×2 must agree, or the four projections \
have split into two vocabularies"
);
let via_display: String = variant.to_string();
assert_eq!(
borrowed_string, via_display,
"From<&Semantic> for String and ToString::to_string \
via Display must resolve identically on \
Semantic::{variant:?} — divergence signals the \
trait-idiomatic borrowed-input owned-`String` axis \
and the Display-routed ToString axis have drifted \
onto different vocabularies"
);
}
let via_iter: Vec<String> = Semantic::ALL.iter().map(String::from).collect();
let via_method: Vec<String> = Semantic::ALL
.iter()
.map(|sem| sem.as_str().to_owned())
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(String::from)` over Semantic::ALL must \
byte-equal `.iter().map(|sem| sem.as_str().to_owned())` \
on every arm — the borrowed-input owned-`String` \
`From<&Semantic> for String` axis is what makes the \
`.map(String::from)` shape route through the substrate-\
primitive Semantic::as_str accessor without a spurious \
`.copied()` / `Copy` deref"
);
for &variant in Semantic::ALL {
let emitted: String = (&variant).into();
let re_parsed: Result<Semantic, ()> =
<Semantic as TryFrom<&str>>::try_from(emitted.as_str());
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic borrowed-input owned-`String` axis \
pair must round-trip Semantic::{variant:?} through \
`(&variant).into::<String>()` and back through \
`TryFrom<&str>` on the owned-`String`'s \
`String::as_str` borrow — a break signals the \
borrowed-input forward-emit owned-`String` axis \
and the reverse-parse `TryFrom<&str>` axis have \
drifted onto different vocabularies"
);
}
}
#[test]
fn semantic_from_into_static_cow_str_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<Semantic>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<Semantic> for Cow<'static, str> impl must round-\
trip Semantic::{variant:?} to the same canonical-\
lowercase kebab byte-string Semantic::as_str returns \
— divergence signals a silent detour off the \
substrate-primitive accessor"
);
assert!(
matches!(via_trait, std::borrow::Cow::Borrowed(_)),
"From<Semantic> for Cow<'static, str> impl must land \
on the zero-alloc Cow::Borrowed arm on \
Semantic::{variant:?} — a Cow::Owned outcome \
signals the projection has silently allocated where \
the substrate-primitive Semantic::as_str \
`&'static str` return makes the borrowed arm the \
type-correct projection"
);
let via_into: std::borrow::Cow<'static, str> = variant.into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<Cow<'static, str>>::into on \
Semantic::{variant:?} must byte-equal \
Semantic::as_str on the same input — the blanket-\
derived Into shape must resolve to the same as_str \
dispatch as the explicit From impl"
);
assert!(
matches!(via_into, std::borrow::Cow::Borrowed(_)),
"Into<Cow<'static, str>>::into on \
Semantic::{variant:?} must land on the zero-alloc \
Cow::Borrowed arm — the blanket-derived Into shape \
must resolve to the same Cow::Borrowed dispatch as \
the explicit From impl"
);
}
}
#[test]
fn semantic_from_into_static_cow_str_agrees_with_paired_axes_on_every_arm() {
for &variant in Semantic::ALL {
let via_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<Semantic>>::from(variant);
let via_static: &'static str = <&'static str as From<Semantic>>::from(variant);
let via_string: String = <String as From<Semantic>>::from(variant);
assert_eq!(
via_cow.as_ref(),
via_static,
"From<Semantic> for Cow<'static, str> and \
From<Semantic> for &'static str must resolve \
identically on Semantic::{variant:?} — divergence \
signals the Cow<'static, str> and &'static str \
return-shape paths have drifted onto different \
emit-sets"
);
assert_eq!(
via_cow.as_ref(),
via_string.as_str(),
"From<Semantic> for Cow<'static, str> and \
From<Semantic> for String must resolve identically \
on Semantic::{variant:?} — divergence signals the \
Cow<'static, str> and String return-shape paths \
have drifted onto different emit-sets"
);
let via_to_string: String = variant.to_string();
assert_eq!(
via_cow.as_ref(),
via_to_string.as_str(),
"From<Semantic> for Cow<'static, str> must byte-\
equal Semantic::to_string on Semantic::{variant:?} \
— divergence signals the trait-idiomatic \
Cow<'static, str> forward-projection axis and the \
ToString-through-Display axis have drifted onto \
different emit-sets"
);
}
let via_iter: Vec<std::borrow::Cow<'static, str>> = Semantic::ALL
.iter()
.copied()
.map(std::borrow::Cow::from)
.collect();
let via_method: Vec<std::borrow::Cow<'static, str>> = Semantic::ALL
.iter()
.map(|sem| std::borrow::Cow::Borrowed(sem.as_str()))
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().copied().map(Cow::from)` over Semantic::ALL \
must byte-equal `.iter().map(|sem| \
Cow::Borrowed(sem.as_str()))` on every arm — the trait-\
idiomatic `From<Semantic> for Cow<'static, str>` axis \
is what makes the `Cow::from` composition route through \
the substrate-primitive Semantic::as_str accessor \
rather than a per-call-site open-code"
);
for cow in &via_iter {
assert!(
matches!(cow, std::borrow::Cow::Borrowed(_)),
"`.iter().copied().map(Cow::from)` over \
Semantic::ALL must land on the zero-alloc \
Cow::Borrowed arm on every element — a Cow::Owned \
outcome signals the pipe has silently allocated \
where the substrate-primitive Semantic::as_str \
`&'static str` return makes the borrowed arm the \
type-correct projection"
);
}
for &variant in Semantic::ALL {
let via_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<Semantic>>::from(variant);
let re_parsed: Result<Semantic, ()> =
<Semantic as TryFrom<&str>>::try_from(via_cow.as_ref());
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic Cow<'static, str> forward-projection \
+ reverse-projection axis pair must round-trip \
Semantic::{variant:?} through \
`.into::<Cow<'static, str>>()` on the owned-input \
surface and back through `TryFrom<&str>` on the \
projection's Cow::as_ref borrow — a break signals \
the Cow<'static, str> forward-emit and reverse-\
parse axes have drifted onto different vocabularies \
(like the sibling FixSafety and Severity pairs, \
Semantic's forward emit and reverse parse share \
the same sixteen inline canonical-lowercase kebab \
byte-strings by construction, so the round-trip \
composes directly)"
);
}
}
#[test]
fn semantic_from_borrowed_into_static_cow_str_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&Semantic>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&Semantic> for Cow<'static, str> impl must \
round-trip &Semantic::{variant:?} to the same \
canonical-lowercase kebab byte-string \
Semantic::as_str returns — divergence signals a \
silent detour off the substrate-primitive accessor"
);
assert!(
matches!(via_trait, std::borrow::Cow::Borrowed(_)),
"From<&Semantic> for Cow<'static, str> impl must \
land on the zero-alloc Cow::Borrowed arm on \
&Semantic::{variant:?} — a Cow::Owned outcome \
signals the projection has silently allocated where \
the substrate-primitive Semantic::as_str \
`&'static str` return makes the borrowed arm the \
type-correct projection"
);
let via_into: std::borrow::Cow<'static, str> = (&variant).into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<Cow<'static, str>>::into on \
&Semantic::{variant:?} must byte-equal \
Semantic::as_str on the same input — the blanket-\
derived Into shape on the borrowed-input surface \
must resolve to the same as_str dispatch as the \
explicit From impl"
);
assert!(
matches!(via_into, std::borrow::Cow::Borrowed(_)),
"Into<Cow<'static, str>>::into on \
&Semantic::{variant:?} must land on the zero-alloc \
Cow::Borrowed arm — the blanket-derived Into shape \
on the borrowed-input surface must resolve to the \
same Cow::Borrowed dispatch as the explicit From \
impl"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds four return-shape paths \
(borrowed-input Cow<'static, str>, owned-input Cow<'static, str>, \
borrowed-input &'static str, borrowed-input String) plus the \
ToString-through-Display witness plus a `.iter().map(Cow::from)` \
pipe witness with zero-alloc discriminator plus a direct \
round-trip witness through TryFrom<&str> over sixteen typed \
variants; the linear per-axis repetition is exactly what the \
fold is pinning — a helper would hide the shape it locks"
)]
fn semantic_from_borrowed_into_static_cow_str_agrees_with_paired_axes_on_every_arm() {
for &variant in Semantic::ALL {
let via_borrowed_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&Semantic>>::from(&variant);
let via_owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<Semantic>>::from(variant);
let via_borrowed_static: &'static str =
<&'static str as From<&Semantic>>::from(&variant);
let via_borrowed_string: String = <String as From<&Semantic>>::from(&variant);
assert_eq!(
via_borrowed_cow.as_ref(),
via_owned_cow.as_ref(),
"From<&Semantic> for Cow<'static, str> and \
From<Semantic> for Cow<'static, str> must resolve \
identically on Semantic::{variant:?} — divergence \
signals the borrowed-input and owned-input \
Cow<'static, str> forward-projection input-shape \
paths have drifted onto different emit-sets"
);
assert_eq!(
via_borrowed_cow.as_ref(),
via_borrowed_static,
"From<&Semantic> for Cow<'static, str> and \
From<&Semantic> for &'static str must resolve \
identically on Semantic::{variant:?} — divergence \
signals the borrowed-input Cow<'static, str> and \
borrowed-input `&'static str` return-shape paths \
have drifted onto different emit-sets"
);
assert_eq!(
via_borrowed_cow.as_ref(),
via_borrowed_string.as_str(),
"From<&Semantic> for Cow<'static, str> and \
From<&Semantic> for String must resolve identically \
on Semantic::{variant:?} — divergence signals the \
borrowed-input Cow<'static, str> and borrowed-input \
owned-`String` return-shape paths have drifted onto \
different emit-sets"
);
let via_to_string: String = variant.to_string();
assert_eq!(
via_borrowed_cow.as_ref(),
via_to_string.as_str(),
"From<&Semantic> for Cow<'static, str> must byte-\
equal Semantic::to_string on Semantic::{variant:?} \
— divergence signals the trait-idiomatic borrowed-\
input Cow<'static, str> forward-projection axis and \
the ToString-through-Display axis have drifted onto \
different emit-sets"
);
assert!(
matches!(via_borrowed_cow, std::borrow::Cow::Borrowed(_)),
"From<&Semantic> for Cow<'static, str> must land on \
the zero-alloc Cow::Borrowed arm on \
&Semantic::{variant:?} — a Cow::Owned outcome \
signals the borrowed-input surface has silently \
allocated where the substrate-primitive \
Semantic::as_str `&'static str` return makes the \
borrowed arm the type-correct projection"
);
}
let via_iter: Vec<std::borrow::Cow<'static, str>> =
Semantic::ALL.iter().map(std::borrow::Cow::from).collect();
let via_method: Vec<std::borrow::Cow<'static, str>> = Semantic::ALL
.iter()
.map(|sem| std::borrow::Cow::Borrowed(sem.as_str()))
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(Cow::from)` over Semantic::ALL — a call \
site whose iteration axis holds `&Semantic` by \
construction — must byte-equal `.iter().map(|sem| \
Cow::Borrowed(sem.as_str()))` on every arm — the \
borrowed-input `From<&Semantic> for Cow<'static, str>` \
axis is what makes the `Cow::from` composition route \
through the substrate-primitive `Semantic::as_str` \
accessor without a spurious `Copy` deref (which would \
only be reachable through the owned-input \
`From<Semantic> for Cow<'static, str>` axis by first \
calling `.copied()` on the iterator)"
);
for cow in &via_iter {
assert!(
matches!(cow, std::borrow::Cow::Borrowed(_)),
"`.iter().map(Cow::from)` over Semantic::ALL must \
land on the zero-alloc Cow::Borrowed arm on every \
element — a Cow::Owned outcome signals the pipe has \
silently allocated through the borrowed-input axis \
where the substrate-primitive Semantic::as_str \
`&'static str` return makes the borrowed arm the \
type-correct projection"
);
}
for &variant in Semantic::ALL {
let via_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&Semantic>>::from(&variant);
let re_parsed: Result<Semantic, ()> =
<Semantic as TryFrom<&str>>::try_from(via_cow.as_ref());
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic borrowed-input Cow<'static, str> \
forward-projection + reverse-projection axis pair \
must round-trip &Semantic::{variant:?} through \
`(&variant).into::<Cow<'static, str>>()` on the \
borrowed-input surface and back through \
`TryFrom<&str>` on the projection's Cow::as_ref \
borrow — a break signals the borrowed-input \
Cow<'static, str> forward-emit and reverse-parse \
axes have drifted onto different vocabularies \
(unlike the peer CaixaKind axis pair, Semantic's \
forward emit and reverse parse share the same \
sixteen inline canonical-lowercase kebab byte-\
strings by construction, so the round-trip composes \
directly)"
);
}
}
#[test]
fn semantic_from_into_box_str_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: Box<str> = <Box<str> as From<Semantic>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<Semantic> for Box<str> impl must round-trip \
Semantic::{variant:?} to the same canonical-lowercase \
kebab byte-string Semantic::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: Box<str> = variant.into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<Box<str>>::into on Semantic::{variant:?} must \
byte-equal Semantic::as_str on the same input — the \
blanket-derived Into shape must resolve to the same \
as_str dispatch as the explicit From impl"
);
}
}
#[test]
fn semantic_from_borrowed_into_box_str_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: Box<str> = <Box<str> as From<&Semantic>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&Semantic> for Box<str> impl must round-trip \
&Semantic::{variant:?} to the same canonical-\
lowercase kebab byte-string Semantic::as_str returns \
— divergence signals a silent detour off the \
substrate-primitive accessor"
);
let via_into: Box<str> = (&variant).into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<Box<str>>::into on &Semantic::{variant:?} must \
byte-equal Semantic::as_str on the same input — the \
blanket-derived Into shape on the borrowed-input \
surface must resolve to the same as_str dispatch as \
the explicit From impl"
);
}
let via_pipe: Vec<Box<str>> = Semantic::ALL.iter().map(Box::<str>::from).collect();
let via_accessor: Vec<&'static str> = Semantic::ALL.iter().map(|s| s.as_str()).collect();
assert_eq!(
via_pipe.len(),
via_accessor.len(),
"Semantic::ALL.iter().map(Box::<str>::from) pipe must \
preserve arity against the paired Semantic::as_str \
accessor — a length divergence signals the borrowed-input \
axis has silently rejected an arm"
);
for (pipe_arm, accessor_arm) in via_pipe.iter().zip(via_accessor.iter()) {
assert_eq!(
pipe_arm.as_ref(),
*accessor_arm,
"Semantic::ALL.iter().map(Box::<str>::from) pipe must \
byte-equal the paired Semantic::ALL.iter().map(|s| \
s.as_str()) pipe on every arm — divergence signals \
the borrowed-input `From<&Semantic> for Box<str>` \
axis has silently detoured off the substrate-\
primitive accessor"
);
}
}
#[test]
fn semantic_from_into_arc_str_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: std::sync::Arc<str> =
<std::sync::Arc<str> as From<Semantic>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<Semantic> for std::sync::Arc<str> impl must \
round-trip Semantic::{variant:?} to the same \
canonical-lowercase kebab byte-string Semantic::as_str \
returns — divergence signals a silent detour off the \
substrate-primitive accessor"
);
let via_into: std::sync::Arc<str> = variant.into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<std::sync::Arc<str>>::into on Semantic::\
{variant:?} must byte-equal Semantic::as_str on the \
same input — the blanket-derived Into shape must \
resolve to the same as_str dispatch as the explicit \
From impl"
);
let owned_static: &'static str = <&'static str as From<Semantic>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_static,
"From<Semantic> for std::sync::Arc<str> and \
From<Semantic> for &'static str must resolve \
identically on Semantic::{variant:?} — divergence \
signals the owned-input std::sync::Arc<str> and \
&'static str return-shape paths have drifted onto \
different emit-sets"
);
let owned_string: String = <String as From<Semantic>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_string.as_str(),
"From<Semantic> for std::sync::Arc<str> and \
From<Semantic> for String must resolve identically \
on Semantic::{variant:?} — divergence signals the \
owned-input std::sync::Arc<str> and owned-`String` \
return-shape paths have drifted onto different \
emit-sets"
);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<Semantic>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_cow.as_ref(),
"From<Semantic> for std::sync::Arc<str> and \
From<Semantic> for Cow<'static, str> must resolve \
identically on Semantic::{variant:?} — divergence \
signals the owned-input std::sync::Arc<str> and \
Cow<'static, str> return-shape paths have drifted \
onto different emit-sets"
);
let owned_box: Box<str> = <Box<str> as From<Semantic>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_box.as_ref(),
"From<Semantic> for std::sync::Arc<str> and \
From<Semantic> for Box<str> must resolve identically \
on Semantic::{variant:?} — divergence signals the \
owned-input std::sync::Arc<str> and Box<str> \
return-shape paths have drifted onto different \
emit-sets"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds four return-shape paths \
(borrowed-input &'static str, String, Cow<'static, str>, \
Box<str>) plus the paired owned-input Arc<str> witness \
and the .iter().map(std::sync::Arc::<str>::from) pipe \
witness into one exhaustive round-trip over \
Semantic::ALL — the accepted line-count cost of keying \
the whole borrowed-input Arc<str> corner to the \
substrate-primitive as_str accessor at the same test-site"
)]
fn semantic_from_borrowed_into_arc_str_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: std::sync::Arc<str> =
<std::sync::Arc<str> as From<&Semantic>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&Semantic> for std::sync::Arc<str> impl must \
round-trip &Semantic::{variant:?} to the same \
canonical-lowercase kebab byte-string Semantic::as_str \
returns — divergence signals a silent detour off the \
substrate-primitive accessor"
);
let via_into: std::sync::Arc<str> = (&variant).into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<std::sync::Arc<str>>::into on &Semantic::\
{variant:?} must byte-equal Semantic::as_str on the \
same input — the blanket-derived Into shape must \
resolve to the same as_str dispatch as the explicit \
From impl"
);
let owned_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<Semantic>>::from(variant);
assert_eq!(
via_trait, owned_arc,
"From<&Semantic> for std::sync::Arc<str> and \
From<Semantic> for std::sync::Arc<str> must resolve \
identically on Semantic::{variant:?} — divergence \
signals the borrowed-input and owned-input \
std::sync::Arc<str> forward-projection input-shape \
paths have drifted onto different emit-sets"
);
let borrowed_static: &'static str = <&'static str as From<&Semantic>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_static,
"From<&Semantic> for std::sync::Arc<str> and \
From<&Semantic> for &'static str must resolve \
identically on Semantic::{variant:?} — divergence \
signals the borrowed-input std::sync::Arc<str> and \
&'static str return-shape paths have drifted onto \
different emit-sets"
);
let borrowed_string: String = <String as From<&Semantic>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_string.as_str(),
"From<&Semantic> for std::sync::Arc<str> and \
From<&Semantic> for String must resolve identically \
on Semantic::{variant:?} — divergence signals the \
borrowed-input std::sync::Arc<str> and owned-`String` \
return-shape paths have drifted onto different \
emit-sets"
);
let borrowed_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&Semantic>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_cow.as_ref(),
"From<&Semantic> for std::sync::Arc<str> and \
From<&Semantic> for Cow<'static, str> must resolve \
identically on Semantic::{variant:?} — divergence \
signals the borrowed-input std::sync::Arc<str> and \
Cow<'static, str> return-shape paths have drifted \
onto different emit-sets"
);
let borrowed_box: Box<str> = <Box<str> as From<&Semantic>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_box.as_ref(),
"From<&Semantic> for std::sync::Arc<str> and \
From<&Semantic> for Box<str> must resolve identically \
on Semantic::{variant:?} — divergence signals the \
borrowed-input std::sync::Arc<str> and Box<str> \
return-shape paths have drifted onto different \
emit-sets"
);
}
let via_pipe: Vec<std::sync::Arc<str>> = Semantic::ALL
.iter()
.map(std::sync::Arc::<str>::from)
.collect();
let via_accessor: Vec<&'static str> = Semantic::ALL.iter().map(|s| s.as_str()).collect();
assert_eq!(
via_pipe.len(),
via_accessor.len(),
"Semantic::ALL.iter().map(std::sync::Arc::<str>::from) pipe \
must preserve arity against the paired \
Semantic::ALL.iter().map(|s| s.as_str()) accessor pipe — \
a length divergence signals the borrowed-input axis has \
silently rejected an arm"
);
for (pipe_arm, accessor_arm) in via_pipe.iter().zip(via_accessor.iter()) {
assert_eq!(
pipe_arm.as_ref(),
*accessor_arm,
"Semantic::ALL.iter().map(std::sync::Arc::<str>::from) \
pipe must byte-equal the paired \
Semantic::ALL.iter().map(|s| s.as_str()) pipe on every \
arm — divergence signals the borrowed-input \
`From<&Semantic> for std::sync::Arc<str>` axis has \
silently detoured off the substrate-primitive accessor"
);
}
}
#[test]
fn semantic_from_into_rc_str_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: std::rc::Rc<str> = <std::rc::Rc<str> as From<Semantic>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<Semantic> for std::rc::Rc<str> impl must \
round-trip Semantic::{variant:?} to the same \
canonical-lowercase kebab byte-string Semantic::as_str \
returns — divergence signals a silent detour off the \
substrate-primitive accessor"
);
let via_into: std::rc::Rc<str> = variant.into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<std::rc::Rc<str>>::into on Semantic::{variant:?} \
must byte-equal Semantic::as_str on the same input — \
the blanket-derived Into shape must resolve to the \
same as_str dispatch as the explicit From impl"
);
let owned_static: &'static str = <&'static str as From<Semantic>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_static,
"From<Semantic> for std::rc::Rc<str> and From<Semantic> \
for &'static str must resolve identically on \
Semantic::{variant:?} — divergence signals the owned-\
input std::rc::Rc<str> and &'static str return-shape \
paths have drifted onto different emit-sets"
);
let owned_string: String = <String as From<Semantic>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_string.as_str(),
"From<Semantic> for std::rc::Rc<str> and From<Semantic> \
for String must resolve identically on \
Semantic::{variant:?} — divergence signals the owned-\
input std::rc::Rc<str> and owned-`String` return-shape \
paths have drifted onto different emit-sets"
);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<Semantic>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_cow.as_ref(),
"From<Semantic> for std::rc::Rc<str> and From<Semantic> \
for Cow<'static, str> must resolve identically on \
Semantic::{variant:?} — divergence signals the owned-\
input std::rc::Rc<str> and Cow<'static, str> return-\
shape paths have drifted onto different emit-sets"
);
let owned_box: Box<str> = <Box<str> as From<Semantic>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_box.as_ref(),
"From<Semantic> for std::rc::Rc<str> and From<Semantic> \
for Box<str> must resolve identically on \
Semantic::{variant:?} — divergence signals the owned-\
input std::rc::Rc<str> and Box<str> return-shape paths \
have drifted onto different emit-sets"
);
let owned_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<Semantic>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_arc.as_ref(),
"From<Semantic> for std::rc::Rc<str> and From<Semantic> \
for std::sync::Arc<str> must resolve identically on \
Semantic::{variant:?} — divergence signals the owned-\
input std::rc::Rc<str> and std::sync::Arc<str> return-\
shape paths have drifted onto different emit-sets (the \
two disjoint reference-counted trait tables have \
desynchronized on the caixa-theme semantic-style axis)"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds five borrowed-input \
return-shape paths (&'static str, String, Cow<'static, \
str>, Box<str>, std::sync::Arc<str>) plus the paired \
owned-input Rc<str> witness and the \
.iter().map(std::rc::Rc::<str>::from) pipe witness into \
one exhaustive round-trip over Semantic::ALL — the \
accepted line-count cost of keying the whole borrowed-\
input Rc<str> corner to the substrate-primitive as_str \
accessor at the same test-site"
)]
fn semantic_from_borrowed_into_rc_str_routes_through_as_str_accessor() {
for &variant in Semantic::ALL {
let via_trait: std::rc::Rc<str> = <std::rc::Rc<str> as From<&Semantic>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&Semantic> for std::rc::Rc<str> impl must \
round-trip &Semantic::{variant:?} to the same \
canonical-lowercase kebab byte-string Semantic::as_str \
returns — divergence signals a silent detour off the \
substrate-primitive accessor"
);
let via_into: std::rc::Rc<str> = (&variant).into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<std::rc::Rc<str>>::into on &Semantic::{variant:?} \
must byte-equal Semantic::as_str on the same input — \
the blanket-derived Into shape must resolve to the \
same as_str dispatch as the explicit From impl"
);
let owned_rc: std::rc::Rc<str> = <std::rc::Rc<str> as From<Semantic>>::from(variant);
assert_eq!(
via_trait, owned_rc,
"From<&Semantic> for std::rc::Rc<str> and From<Semantic> \
for std::rc::Rc<str> must resolve identically on \
Semantic::{variant:?} — divergence signals the \
borrowed-input and owned-input std::rc::Rc<str> \
forward-projection input-shape paths have drifted onto \
different emit-sets"
);
let borrowed_static: &'static str = <&'static str as From<&Semantic>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_static,
"From<&Semantic> for std::rc::Rc<str> and From<&Semantic> \
for &'static str must resolve identically on \
Semantic::{variant:?} — divergence signals the \
borrowed-input std::rc::Rc<str> and &'static str \
return-shape paths have drifted onto different \
emit-sets"
);
let borrowed_string: String = <String as From<&Semantic>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_string.as_str(),
"From<&Semantic> for std::rc::Rc<str> and From<&Semantic> \
for String must resolve identically on \
Semantic::{variant:?} — divergence signals the \
borrowed-input std::rc::Rc<str> and owned-`String` \
return-shape paths have drifted onto different \
emit-sets"
);
let borrowed_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&Semantic>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_cow.as_ref(),
"From<&Semantic> for std::rc::Rc<str> and From<&Semantic> \
for Cow<'static, str> must resolve identically on \
Semantic::{variant:?} — divergence signals the \
borrowed-input std::rc::Rc<str> and Cow<'static, str> \
return-shape paths have drifted onto different \
emit-sets"
);
let borrowed_box: Box<str> = <Box<str> as From<&Semantic>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_box.as_ref(),
"From<&Semantic> for std::rc::Rc<str> and From<&Semantic> \
for Box<str> must resolve identically on \
Semantic::{variant:?} — divergence signals the \
borrowed-input std::rc::Rc<str> and Box<str> return-\
shape paths have drifted onto different emit-sets"
);
let borrowed_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<&Semantic>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_arc.as_ref(),
"From<&Semantic> for std::rc::Rc<str> and From<&Semantic> \
for std::sync::Arc<str> must resolve identically on \
Semantic::{variant:?} — divergence signals the \
borrowed-input std::rc::Rc<str> and std::sync::Arc<str> \
return-shape paths have drifted onto different emit-\
sets (the two disjoint reference-counted trait tables \
have desynchronized on the caixa-theme semantic-style \
axis under the borrowed-input corner)"
);
}
let via_pipe: Vec<std::rc::Rc<str>> =
Semantic::ALL.iter().map(std::rc::Rc::<str>::from).collect();
let via_accessor: Vec<&'static str> = Semantic::ALL.iter().map(|s| s.as_str()).collect();
assert_eq!(
via_pipe.len(),
via_accessor.len(),
"Semantic::ALL.iter().map(std::rc::Rc::<str>::from) pipe \
must preserve arity against the paired \
Semantic::ALL.iter().map(|s| s.as_str()) accessor pipe — a \
length divergence signals the borrowed-input axis has \
silently rejected an arm"
);
for (pipe_arm, accessor_arm) in via_pipe.iter().zip(via_accessor.iter()) {
assert_eq!(
pipe_arm.as_ref(),
*accessor_arm,
"Semantic::ALL.iter().map(std::rc::Rc::<str>::from) pipe \
must byte-equal the paired \
Semantic::ALL.iter().map(|s| s.as_str()) pipe on every \
arm — divergence signals the borrowed-input \
`From<&Semantic> for std::rc::Rc<str>` axis has \
silently detoured off the substrate-primitive accessor"
);
}
}
#[test]
fn semantic_wire_names_covers_every_arm() {
assert_eq!(
super::Semantic::WIRE_NAMES.len(),
super::Semantic::ALL.len(),
"Semantic::WIRE_NAMES.len() must byte-equal \
Semantic::ALL.len() — a mismatch means the roster and \
the enum's arm-set have drifted; downstream consumers \
that fan through both will silently disagree on the \
accepted arm-set"
);
for &variant in super::Semantic::ALL {
let wire = variant.as_str();
assert!(
super::Semantic::WIRE_NAMES.contains(&wire),
"Semantic::{variant:?}.as_str() = {wire:?} must be a \
member of Semantic::WIRE_NAMES — the emitter and the \
roster have drifted out of lockstep"
);
}
for tag in super::Semantic::WIRE_NAMES {
let first = tag.chars().next().unwrap_or_else(|| {
panic!(
"Semantic::WIRE_NAMES entry {tag:?} must be a \
non-empty lowercase-tag byte-string"
)
});
assert!(
first.is_ascii_lowercase(),
"Semantic::WIRE_NAMES entry {tag:?} must open with a \
lowercase ASCII byte (matching the substrate-wide \
lowercase-tag convention every peer closed-set enum \
whose canonical projection is a lowercase-tag byte-\
string carries) — an entry opening with an uppercase \
byte would collide the roster with any hypothetical \
peer PascalCase wire-form axis a downstream consumer \
might disambiguate against (the Debug-derived \
`\"Keyword\"` / `\"Symbol\"` / `\"KeywordArg\"` / … \
shapes)"
);
}
assert_eq!(
super::Semantic::WIRE_NAMES,
&[
super::CAIXA_THEME_SEMANTIC_WIRE_KEYWORD,
super::CAIXA_THEME_SEMANTIC_WIRE_SYMBOL,
super::CAIXA_THEME_SEMANTIC_WIRE_KEYWORD_ARG,
super::CAIXA_THEME_SEMANTIC_WIRE_STRING,
super::CAIXA_THEME_SEMANTIC_WIRE_NUMBER,
super::CAIXA_THEME_SEMANTIC_WIRE_LITERAL,
super::CAIXA_THEME_SEMANTIC_WIRE_COMMENT,
super::CAIXA_THEME_SEMANTIC_WIRE_ACCENT,
super::CAIXA_THEME_SEMANTIC_WIRE_MUTED,
super::CAIXA_THEME_SEMANTIC_WIRE_ERROR,
super::CAIXA_THEME_SEMANTIC_WIRE_WARNING,
super::CAIXA_THEME_SEMANTIC_WIRE_INFO,
super::CAIXA_THEME_SEMANTIC_WIRE_HINT,
super::CAIXA_THEME_SEMANTIC_WIRE_ADDED,
super::CAIXA_THEME_SEMANTIC_WIRE_REMOVED,
super::CAIXA_THEME_SEMANTIC_WIRE_UNCHANGED,
],
"Semantic::WIRE_NAMES must enumerate every arm's wire-form \
tag exactly once, in variant declaration order (Keyword → \
Symbol → KeywordArg → String → Number → Literal → Comment \
→ Accent → Muted → Error → Warning → Info → Hint → Added \
→ Removed → Unchanged)"
);
for (&variant, tag) in super::Semantic::ALL.iter().zip(super::Semantic::WIRE_NAMES) {
assert_eq!(
super::Semantic::from_wire(tag),
Some(variant),
"Semantic::from_wire({tag:?}) must round-trip back to \
Semantic::{variant:?} — emitter and parser have \
drifted off the paired CAIXA_THEME_SEMANTIC_WIRE_* \
const family"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds the substrate-primitive \
as_str accessor's `.as_bytes()` byte-tail plus the \
paired str-view (AsRef<str>, Display, as_str) and \
reverse-projection ({&'static str, String, Cow<'static, \
str>, Box<str>, std::sync::Arc<str>, std::rc::Rc<str>}) \
return-shape axes' `.as_bytes()` byte-tails plus a \
<T: AsRef<[u8]>>-bound-consumer witness plus a \
blake3::Hasher::update-shape byte-input surface witness \
into one exhaustive round-trip over Semantic::ALL — \
the accepted line-count cost of extending the byte-view \
axis keyed to the substrate-primitive as_str accessor \
at the same test-site"
)]
#[allow(
clippy::needless_borrows_for_generic_args,
reason = "the borrowed-input surface (&variant) is exercised \
deliberately: the `<T: AsRef<[u8]>>`-bound consumer and \
the `blake3::Hasher::update`-shape byte-input surface \
both accept either owned or borrowed input through the \
standard-library blanket `impl<T: ?Sized + AsRef<[u8]>> \
AsRef<[u8]> for &T`, and this pin round-trips both \
input shapes to lock the borrowed-input path load-\
bearing against a future silent regression"
)]
fn semantic_as_ref_bytes_routes_through_as_str_accessor() {
fn generic_bytes_sink<T: AsRef<[u8]>>(t: T) -> Vec<u8> {
t.as_ref().to_vec()
}
struct MockHasher(Vec<u8>);
impl MockHasher {
fn new() -> Self {
Self(Vec::new())
}
fn update(&mut self, bytes: impl AsRef<[u8]>) -> &mut Self {
self.0.extend_from_slice(bytes.as_ref());
self
}
fn finalize(self) -> Vec<u8> {
self.0
}
}
for &variant in super::Semantic::ALL {
let via_trait: &[u8] = <super::Semantic as AsRef<[u8]>>::as_ref(&variant);
let via_method_bytes: &[u8] = variant.as_str().as_bytes();
assert_eq!(
via_trait, via_method_bytes,
"AsRef<[u8]> for Semantic impl must byte-equal \
Semantic::as_str().as_bytes() on \
Semantic::{variant:?} — divergence signals a silent \
detour off the substrate-primitive accessor"
);
let via_as_ref_str: &str = <super::Semantic as AsRef<str>>::as_ref(&variant);
assert_eq!(
via_trait,
via_as_ref_str.as_bytes(),
"AsRef<[u8]> for Semantic and AsRef<str> for Semantic \
`.as_bytes()` must byte-equal on Semantic::{variant:?}"
);
let via_display: String = format!("{variant}");
assert_eq!(
via_trait,
via_display.as_bytes(),
"AsRef<[u8]> for Semantic and \
std::fmt::Display::fmt::<Semantic> `.as_bytes()` must \
byte-equal on Semantic::{variant:?}"
);
let via_as_str: &'static str = variant.as_str();
assert_eq!(
via_trait,
via_as_str.as_bytes(),
"AsRef<[u8]> for Semantic and Semantic::as_str \
`.as_bytes()` must byte-equal on Semantic::{variant:?}"
);
let via_static: &'static str = <&'static str>::from(variant);
assert_eq!(
via_trait,
via_static.as_bytes(),
"AsRef<[u8]> for Semantic and From<Semantic> for \
&'static str `.as_bytes()` must byte-equal on \
Semantic::{variant:?}"
);
let via_string: String = String::from(variant);
assert_eq!(
via_trait,
via_string.as_bytes(),
"AsRef<[u8]> for Semantic and From<Semantic> for \
String `.as_bytes()` must byte-equal on \
Semantic::{variant:?}"
);
let via_cow: std::borrow::Cow<'static, str> =
std::borrow::Cow::<'static, str>::from(variant);
assert_eq!(
via_trait,
via_cow.as_bytes(),
"AsRef<[u8]> for Semantic and From<Semantic> for \
Cow<'static, str> `.as_bytes()` must byte-equal on \
Semantic::{variant:?}"
);
let via_box: Box<str> = Box::<str>::from(variant);
assert_eq!(
via_trait,
via_box.as_bytes(),
"AsRef<[u8]> for Semantic and From<Semantic> for \
Box<str> `.as_bytes()` must byte-equal on \
Semantic::{variant:?}"
);
let atomic_shared: std::sync::Arc<str> = std::sync::Arc::<str>::from(variant);
assert_eq!(
via_trait,
atomic_shared.as_bytes(),
"AsRef<[u8]> for Semantic and From<Semantic> for \
std::sync::Arc<str> `.as_bytes()` must byte-equal on \
Semantic::{variant:?}"
);
let single_thread_shared: std::rc::Rc<str> = std::rc::Rc::<str>::from(variant);
assert_eq!(
via_trait,
single_thread_shared.as_bytes(),
"AsRef<[u8]> for Semantic and From<Semantic> for \
std::rc::Rc<str> `.as_bytes()` must byte-equal on \
Semantic::{variant:?}"
);
let via_generic_owned = generic_bytes_sink(variant);
assert_eq!(
via_trait, via_generic_owned,
"generic `<T: AsRef<[u8]>>`-bound consumer on the \
owned-input surface must byte-equal the substrate-\
primitive as_str accessor's byte-tail on \
Semantic::{variant:?}"
);
let via_generic_borrowed = generic_bytes_sink(&variant);
assert_eq!(
via_trait, via_generic_borrowed,
"generic `<T: AsRef<[u8]>>`-bound consumer on the \
borrowed-input surface must byte-equal the substrate-\
primitive as_str accessor's byte-tail on \
Semantic::{variant:?}"
);
let mut hasher_owned_input = MockHasher::new();
hasher_owned_input.update(variant);
let owned_digest = hasher_owned_input.finalize();
assert_eq!(
owned_digest.as_slice(),
via_trait,
"blake3::Hasher::update-shape byte-input surface on the \
owned-input surface must byte-equal the substrate-\
primitive as_str accessor's byte-tail on \
Semantic::{variant:?}"
);
let mut hasher_borrowed_input = MockHasher::new();
hasher_borrowed_input.update(&variant);
let borrowed_digest = hasher_borrowed_input.finalize();
assert_eq!(
borrowed_digest.as_slice(),
via_trait,
"blake3::Hasher::update-shape byte-input surface on the \
borrowed-input surface must byte-equal the substrate-\
primitive as_str accessor's byte-tail on \
Semantic::{variant:?}"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds the substrate-primitive \
as_str accessor's `.as_bytes().to_vec()` byte-tail plus \
the paired AsRef<[u8]> borrowed byte-view axis and the \
str-owned reverse-projection family's `.into_bytes()` / \
`.as_bytes().to_vec()` byte-tails plus a \
<T: Into<Vec<u8>>>-bound-consumer witness plus a \
std::io::Write::write_all-shape owned-byte-sink surface \
witness plus a Debug-derive rejection witness into one \
exhaustive round-trip over Semantic::ALL — the accepted \
line-count cost of extending the byte-owned reverse-\
projection axis keyed to the substrate-primitive as_str \
accessor at the same test-site"
)]
fn semantic_from_into_owned_vec_bytes_routes_through_as_str_accessor() {
fn generic_owned_bytes_sink<T: Into<Vec<u8>>>(t: T) -> Vec<u8> {
t.into()
}
struct MockOwnedByteSink(Vec<u8>);
impl MockOwnedByteSink {
fn new() -> Self {
Self(Vec::new())
}
fn write_all(&mut self, bytes: impl Into<Vec<u8>>) -> &mut Self {
self.0.extend_from_slice(&bytes.into());
self
}
fn finalize(self) -> Vec<u8> {
self.0
}
}
for &variant in super::Semantic::ALL {
let via_owned_from: Vec<u8> = <Vec<u8> as From<super::Semantic>>::from(variant);
let via_borrowed_from: Vec<u8> = <Vec<u8> as From<&super::Semantic>>::from(&variant);
let via_method_bytes: Vec<u8> = variant.as_str().as_bytes().to_vec();
assert_eq!(
via_owned_from, via_method_bytes,
"From<Semantic> for Vec<u8> impl must byte-equal \
Semantic::as_str().as_bytes().to_vec() on \
Semantic::{variant:?} — divergence signals a silent \
detour off the substrate-primitive accessor"
);
assert_eq!(
via_borrowed_from, via_method_bytes,
"From<&Semantic> for Vec<u8> impl must byte-equal \
Semantic::as_str().as_bytes().to_vec() on \
Semantic::{variant:?} — divergence signals a silent \
detour off the substrate-primitive accessor"
);
assert_eq!(
via_owned_from, via_borrowed_from,
"From<Semantic> for Vec<u8> and From<&Semantic> for \
Vec<u8> must byte-equal each other on \
Semantic::{variant:?} — divergence signals the owned-\
input and borrowed-input paths have drifted off the \
same substrate-primitive as_str accessor"
);
let borrowed_bytes: &[u8] = <super::Semantic as AsRef<[u8]>>::as_ref(&variant);
assert_eq!(
via_owned_from,
borrowed_bytes.to_vec(),
"From<Semantic> for Vec<u8> and AsRef<[u8]> for Semantic \
must resolve to byte-equal byte-tails on \
Semantic::{variant:?} — divergence signals the byte-\
owned and byte-view axes have drifted off the same \
substrate-primitive as_str accessor"
);
let owned_string: String = <String as From<super::Semantic>>::from(variant);
assert_eq!(
via_owned_from,
owned_string.into_bytes(),
"From<Semantic> for Vec<u8> and \
String::from(semantic).into_bytes() must resolve to \
byte-equal byte-tails on Semantic::{variant:?}"
);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<super::Semantic>>::from(variant);
assert_eq!(
via_owned_from,
owned_cow.as_bytes().to_vec(),
"From<Semantic> for Vec<u8> and From<Semantic> for \
Cow<'static, str> must resolve to byte-equal byte-\
tails on Semantic::{variant:?}"
);
let owned_box: Box<str> = <Box<str> as From<super::Semantic>>::from(variant);
assert_eq!(
via_owned_from,
owned_box.as_bytes().to_vec(),
"From<Semantic> for Vec<u8> and From<Semantic> for \
Box<str> must resolve to byte-equal byte-tails on \
Semantic::{variant:?}"
);
let owned_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<super::Semantic>>::from(variant);
assert_eq!(
via_owned_from,
owned_arc.as_bytes().to_vec(),
"From<Semantic> for Vec<u8> and From<Semantic> for \
std::sync::Arc<str> must resolve to byte-equal byte-\
tails on Semantic::{variant:?}"
);
let owned_rc_str: std::rc::Rc<str> =
<std::rc::Rc<str> as From<super::Semantic>>::from(variant);
assert_eq!(
via_owned_from,
owned_rc_str.as_bytes().to_vec(),
"From<Semantic> for Vec<u8> and From<Semantic> for \
std::rc::Rc<str> must resolve to byte-equal byte-tails \
on Semantic::{variant:?}"
);
let debug_bytes = format!("{variant:?}").into_bytes();
assert_ne!(
via_owned_from, debug_bytes,
"From<Semantic> for Vec<u8> must land on the canonical-\
lowercase kebab byte-string (Semantic::as_str), not the \
PascalCase byte-string `format!(\"{{:?}}\", variant)`; \
if this fails on Semantic::{variant:?}, the byte-owned \
axis has silently collapsed back onto the Debug-derive \
output"
);
}
for &variant in super::Semantic::ALL {
let via_generic_owned = generic_owned_bytes_sink(variant);
let variant_ref: &super::Semantic = &variant;
let via_generic_borrowed = generic_owned_bytes_sink(variant_ref);
let via_method_bytes: Vec<u8> = variant.as_str().as_bytes().to_vec();
assert_eq!(
via_generic_owned, via_method_bytes,
"generic `<T: Into<Vec<u8>>>`-bound consumer on the \
owned-input surface must byte-equal the substrate-\
primitive as_str accessor's byte-tail on \
Semantic::{variant:?}"
);
assert_eq!(
via_generic_borrowed, via_method_bytes,
"generic `<T: Into<Vec<u8>>>`-bound consumer on the \
borrowed-input surface must byte-equal the substrate-\
primitive as_str accessor's byte-tail on \
Semantic::{variant:?}"
);
}
for &variant in super::Semantic::ALL {
let via_method_bytes: Vec<u8> = variant.as_str().as_bytes().to_vec();
let mut sink_owned = MockOwnedByteSink::new();
sink_owned.write_all(variant);
let owned_written = sink_owned.finalize();
assert_eq!(
owned_written, via_method_bytes,
"std::io::Write::write_all-shape owned-byte-sink \
surface on the owned-input surface must byte-equal the \
substrate-primitive as_str accessor's byte-tail on \
Semantic::{variant:?}"
);
let mut sink_borrowed = MockOwnedByteSink::new();
let variant_ref: &super::Semantic = &variant;
sink_borrowed.write_all(variant_ref);
let borrowed_written = sink_borrowed.finalize();
assert_eq!(
borrowed_written, via_method_bytes,
"std::io::Write::write_all-shape owned-byte-sink \
surface on the borrowed-input surface must byte-equal \
the substrate-primitive as_str accessor's byte-tail on \
Semantic::{variant:?}"
);
}
}
#[test]
fn semantic_try_from_bytes_routes_through_from_wire_accessor() {
for &variant in super::Semantic::ALL {
let wire_bytes: &[u8] = variant.as_str().as_bytes();
assert_eq!(
<super::Semantic as TryFrom<&[u8]>>::try_from(wire_bytes),
Ok(variant),
"TryFrom<&[u8]> impl on Semantic must round-trip \
Semantic::{variant:?}.as_str().as_bytes() back to \
Ok(Semantic::{variant:?}) — divergence from \
Semantic::from_wire signals a silent detour off the \
substrate-primitive accessor"
);
assert_eq!(
<super::Semantic as TryFrom<&[u8]>>::try_from(wire_bytes).ok(),
super::Semantic::from_wire(variant.as_str()),
"TryFrom<&[u8]> ok()-projection on \
Semantic::{variant:?}.as_str().as_bytes() must byte-\
equal Semantic::from_wire on the paired &str input"
);
let via_str: Result<super::Semantic, ()> =
<super::Semantic as TryFrom<&str>>::try_from(variant.as_str());
let via_bytes: Result<super::Semantic, ()> =
<super::Semantic as TryFrom<&[u8]>>::try_from(wire_bytes);
assert_eq!(
via_bytes, via_str,
"TryFrom<&[u8]> and TryFrom<&str> reverse-projection \
axes on Semantic must agree on \
Semantic::{variant:?} — divergence signals the byte-\
view and str-view reverse paths have drifted off the \
same substrate-primitive from_wire accessor"
);
let via_asref: &[u8] = <super::Semantic as AsRef<[u8]>>::as_ref(&variant);
assert_eq!(
<super::Semantic as TryFrom<&[u8]>>::try_from(via_asref),
Ok(variant),
"TryFrom<&[u8]> ∘ AsRef<[u8]> must round-trip \
Semantic::{variant:?} — divergence signals the \
forward and reverse byte-view axes have drifted off \
the same substrate-primitive as_str/from_wire pair"
);
let owned_bytes: Vec<u8> = <Vec<u8> as From<super::Semantic>>::from(variant);
assert_eq!(
<super::Semantic as TryFrom<&[u8]>>::try_from(owned_bytes.as_slice()),
Ok(variant),
"TryFrom<&[u8]> ∘ From<Semantic> for Vec<u8> must \
round-trip Semantic::{variant:?} — divergence \
signals the byte-owned reverse-projection axis has \
drifted off the paired byte-view reverse axis"
);
let borrowed_owned_bytes: Vec<u8> = <Vec<u8> as From<&super::Semantic>>::from(&variant);
assert_eq!(
<super::Semantic as TryFrom<&[u8]>>::try_from(borrowed_owned_bytes.as_slice()),
Ok(variant),
"TryFrom<&[u8]> ∘ From<&Semantic> for Vec<u8> must \
round-trip Semantic::{variant:?} — divergence \
signals the borrowed-input byte-owned axis has \
drifted off the paired byte-view reverse axis"
);
}
}
#[test]
fn semantic_try_from_bytes_rejects_unknown_and_non_utf8_bytes() {
let non_utf8_rejected: &[&[u8]] = &[
&[0xFF],
&[0x80],
&[0xC3],
&[0xFF, 0xFE],
&[0xED, 0xA0, 0x80],
];
for &input in non_utf8_rejected {
assert_eq!(
<super::Semantic as TryFrom<&[u8]>>::try_from(input),
Err(()),
"TryFrom<&[u8]> impl on Semantic must reject the \
non-UTF-8 byte-sequence {input:?} with Err(()) — \
silent acceptance signals the UTF-8 validation path \
collapsed onto a default arm rather than the trait-\
idiomatic unit-error"
);
}
let unknown_wire_rejected: &[&[u8]] = &[
b"",
b" ",
b"\n",
b"\t",
b"Keyword",
b"KEYWORD",
b"KeywordArg",
b"keyword_arg",
b"keyword arg",
b"keywordarg",
b"keywords",
b"keywor",
b"namespace",
b"deleted",
b"safe",
b"unsafe",
b"proven",
b"rejected",
b"biblioteca",
b"servico",
b"one-for-one",
b"empty",
b"safety",
b"compliance",
b"keyword ",
b" keyword",
b"keyword\n",
b"keyword\t",
b"?",
b"\"keyword\"",
];
for &input in unknown_wire_rejected {
assert_eq!(
<super::Semantic as TryFrom<&[u8]>>::try_from(input),
Err(()),
"TryFrom<&[u8]> impl on Semantic must reject the \
valid-UTF-8-but-unknown-wire byte-string {input:?} \
with Err(()) — silent acceptance signals an accept-\
set widening off the paired Semantic::from_wire \
resolver, or a cross-axis leak from a sibling \
closed-set typed-enum axis's non-shared arm-set"
);
}
}
}