Struct SignatureTypeSpec

pub struct SignatureTypeSpec {
    pub base: TypeSignature,
}

Type specification signature for complex and generic types.

Represents type specification signatures according to ECMA-335 Section II.23.2.14. Type specifications are used to represent complex types that cannot be expressed through simple metadata tokens, particularly generic instantiations and complex nested types.

Type Specification Uses

Generic Instantiations

Complex generic types with specific type arguments:

• List<int> - Generic class with value type argument
• Dictionary<string, object> - Generic class with multiple arguments
• Array<T> - Generic array with type parameter

Nested Generic Types

Generic types nested within other generic types:

• Outer<T>.Inner<U> - Nested generic classes
• Container<T>.Collection<U>.Item<V> - Multiple nesting levels

Complex Array Types

Multi-dimensional and modified array types:

• int[,] - Multi-dimensional arrays
• volatile int[] - Arrays with custom modifiers
• T[][] - Jagged arrays with generic elements

Function Pointer Types

Complex function pointer signatures:

• delegate*<int, string, bool> - Function pointers with multiple parameters
• delegate* managed<T, U> - Generic function pointers

Binary Format (ECMA-335)

Type specifications are encoded as complete type signatures:

TypeSpec ::= Type

Where Type can be any valid type signature including complex generic instantiations.

Examples

Generic Instantiation

use dotscope::metadata::signatures::{SignatureTypeSpec, TypeSignature};
use dotscope::metadata::token::Token;

let list_of_int = SignatureTypeSpec {
    base: TypeSignature::GenericInst(
        Box::new(TypeSignature::Class(Token::new(0x02000001))), // List<T> class
        vec![TypeSignature::I4]                                 // int argument
    ),
};

Complex Array Type

use dotscope::metadata::signatures::{SignatureTypeSpec, TypeSignature, SignatureArray};
use dotscope::metadata::typesystem::ArrayDimensions;

let int_2d_array = SignatureTypeSpec {
    base: TypeSignature::Array(SignatureArray {
        base: Box::new(TypeSignature::I4),
        rank: 2,
        dimensions: vec![
            ArrayDimensions { size: None, lower_bound: None },
            ArrayDimensions { size: None, lower_bound: None },
        ],
    }),
};

Performance Considerations

• Type specifications are resolved once and cached
• Complex generic instantiations may have resolution overhead
• Runtime type checking enforces specification constraints

Thread Safety

SignatureTypeSpec is immutable after construction and safe to share between threads.

ECMA-335 Compliance

This structure implements ECMA-335 Partition II, Section 23.2.14 (TypeSpec) and supports all standard type specification scenarios.

See Also

• TypeSignature: For the underlying type representation
• SignatureMethodSpec: For method specification signatures
• crate::metadata::token::Token: For metadata token references

Fields

base: TypeSignature

The complete type signature for this type specification.

Contains the full type signature that defines this type specification. This can be any valid type signature, but is typically used for complex types that require full signature representation.

Type Categories

• Generic Instantiations: List<T>, Dictionary<K,V>
• Complex Arrays: Multi-dimensional or modified arrays
• Function Pointers: Complex delegate types
• Nested Types: Generic types within generic types

Resolution

The type signature is resolved by the runtime to create the actual type representation used during execution.

Trait Implementations

impl Clone for SignatureTypeSpec

fn clone(&self) -> SignatureTypeSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignatureTypeSpec

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

Formats the value using the given formatter.

impl Default for SignatureTypeSpec

fn default() -> SignatureTypeSpec

Returns the “default value” for a type.

impl PartialEq for SignatureTypeSpec

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