Struct Token

pub struct Token(pub u32);

A metadata token representing a reference to a specific entry within a metadata table.

Tokens are the fundamental addressing mechanism in .NET metadata, providing a uniform way to reference entries across different metadata tables. Each token encodes both the target table type and the specific row within that table.

Token Format

A token is a 32-bit value structured as follows:

┌─────────────┬───────────────────────────────────┐
│ Table (8b)  │        Row Index (24b)            │
├─────────────┼───────────────────────────────────┤
│   31-24     │            23-0                   │
└─────────────┴───────────────────────────────────┘

Table Identification

The high byte identifies the metadata table type according to ECMA-335:

• 0x01: TypeRef - References to external types
• 0x02: TypeDef - Type definitions within this assembly
• 0x04: FieldDef - Field definitions
• 0x06: MethodDef - Method definitions
• 0x0A: MemberRef - References to external members
• And many others…

Row Addressing

The low 24 bits provide a 1-based index into the specified table, allowing for up to 16,777,215 entries per table. A row index of 0 indicates a null reference.

Usage in IL and Metadata

Tokens appear in multiple contexts:

• IL Instructions: call, newobj, ldtoken, etc.
• Table References: Cross-references between metadata tables
• Debug Information: Linking debug data to metadata
• Reflection API: Internal representation of metadata references

Tuple Fields

0: u32

Implementations

impl Token

pub fn new(value: u32) -> Self

Creates a new token from a raw 32-bit value.

This constructor accepts any 32-bit value and interprets it as a metadata token according to the ECMA-335 token format. No validation is performed on the input value, allowing for the creation of tokens that may not correspond to valid metadata entries.

Arguments

• value - The raw 32-bit token value with table ID in high byte and row index in low 24 bits

Returns

A new Token instance wrapping the provided value.

pub fn value(&self) -> u32

Returns the raw 32-bit token value.

This method provides access to the underlying token representation as used in IL instructions, metadata tables, and the .NET reflection API.

Returns

The complete 32-bit token value including both table identifier and row index.

pub fn table(&self) -> u8

Extracts the table identifier from the token.

Returns the high byte (bits 24-31) of the token, which identifies the metadata table type according to ECMA-335 specifications. This value corresponds to the table enumeration used throughout the metadata system.

Returns

The 8-bit table identifier (0x00-0xFF).

Common Table IDs

• 0x01: TypeRef
• 0x02: TypeDef
• 0x04: FieldDef
• 0x06: MethodDef
• 0x0A: MemberRef
• 0x1B: TypeSpec
• 0x2B: MethodSpec

pub fn row(&self) -> u32

Extracts the row index from the token.

Returns the low 24 bits (bits 0-23) of the token, which represent the 1-based row index within the specified metadata table. A value of 0 indicates a null reference that doesn’t point to any table entry.

Returns

The 24-bit row index (0-16,777,215), where 0 represents null.

Row Index Semantics

• 1-based indexing: Valid row indexes start from 1
• Null reference: Row index 0 indicates no target entry
• Maximum capacity: Up to 16,777,215 entries per table

pub fn is_null(&self) -> bool

Returns true if this token represents a null reference.

A null token has a value of 0, indicating that it doesn’t reference any metadata table entry. Null tokens are used in metadata to represent optional or absent references.

Returns

true if the token value is 0, false otherwise.

Usage in Metadata

Null tokens commonly appear in:

• Optional parent type references
• Unused coded index entries
• Default value placeholders
• Conditional reference fields

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Token

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

Formats the token for debugging output with detailed breakdown.

The debug format includes the raw token value in hexadecimal, the table identifier, and the row index for comprehensive debugging information.

Format

Token(0x{:08x}, table: 0x{:02x}, row: {})

impl Display for Token

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

Formats the token for user display as a hexadecimal value.

The display format shows only the raw token value in standard hexadecimal notation, suitable for user-facing output and logging.

Format

0x{:08x} - 8-digit uppercase hexadecimal with 0x prefix

impl From<Token> for u32

fn from(token: Token) -> Self

Extracts the raw 32-bit value from a Token.

This conversion provides access to the underlying token representation for use in contexts requiring raw token values, such as IL generation or metadata serialization.

impl From<u32> for Token

fn from(value: u32) -> Self

Converts a raw 32-bit value into a Token.

This conversion allows for ergonomic token creation from integer literals and variables. The conversion is identical to Token::new but provides the standard Rust conversion trait interface.

impl Hash for Token

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

Computes the hash value for this token.

The hash is computed directly from the underlying 32-bit value, providing efficient and consistent hashing for use in hash-based collections like HashMap and HashSet.

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 Token

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

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

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

impl Eq for Token

impl StructuralPartialEq for Token