Struct DeclId 

#[repr(transparent)]
pub struct DeclId(pub u128);

Identifies a type declaration, independent of type parameters.

Think of DeclId as a “type-parameter-erased” version of Shape::id. While Vec<u32> and Vec<String> have different Shape::id values, they share the same DeclId because they come from the same Vec<T> declaration.

How DeclId is computed

Non-generic types

For types without type parameters (like u32 or MyStruct), DeclId is trivial—it can simply equal the hash of the type identifier. When implementing Facet for such types, you don’t need to do anything special; if you don’t call .decl_id() on the builder, it’s automatically computed from the type_identifier.

Generic types with #[derive(Facet)]

For generic types using the derive macro, DeclId is computed from:

file!():line!():column!()#kind#TypeName

For example: src/lib.rs:42:1#struct#Wrapper

This strategy assumes no two declarations exist at the exact same source location. This isn’t strictly true with macros that generate multiple types, which is why we also include the type name. Even so, this can be defeated in edge cases—it’s a best-effort approach.

Foreign generic types (manual Facet implementations)

When implementing Facet for an external generic type (like Vec, Arc, HashMap), set the module_path on the builder:

ShapeBuilder::for_sized::<Arc<T>>("Arc")
    .module_path("alloc::sync")
    // ... other fields ...
    .build()

The DeclId is then auto-computed from: @{module_path}#{kind}#{type_identifier}

For example, Arc in alloc::sync with type struct produces: @alloc::sync#struct#Arc

This is also not foolproof—if you have two different versions of the same crate in your dependency graph, they’ll produce the same DeclId even though they’re technically different declarations.

Example

use facet::Facet;

#[derive(Facet)]
struct Wrapper<T> {
    inner: T,
}

// Different types (different Shape::id)
assert!(<Wrapper<u32>>::SHAPE.id != <Wrapper<String>>::SHAPE.id);

// Same declaration (same Shape::decl_id)
assert!(<Wrapper<u32>>::SHAPE.decl_id == <Wrapper<String>>::SHAPE.decl_id);

Stability

DeclId is completely opaque and provides no stability guarantees:

• NOT stable across different compilations
• NOT stable across refactors (adding a comment changes line numbers)
• NOT stable across reformatting (column numbers change)
• NOT suitable for persistence or serialization

The only guarantee: within a single compilation, the same declaration produces the same DeclId.

This is sufficient for runtime use cases like “group all instantiations of Vec<T> in this program” but NOT for cross-compilation comparisons or persistence.

Tuple Fields

0: u128

Implementations

impl DeclId

pub const fn new(hash: u128) -> Self

Create a DeclId from a raw hash value.

This is typically called by the derive macro using const_fnv1a_hash.

Trait Implementations

impl Clone for DeclId

fn clone(&self) -> DeclId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeclId

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

Formats the value using the given formatter.

impl Hash for DeclId

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 Ord for DeclId

fn cmp(&self, other: &DeclId) -> 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 DeclId

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

fn partial_cmp(&self, other: &DeclId) -> 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 Copy for DeclId

impl Eq for DeclId

impl StructuralPartialEq for DeclId