Struct TypeId 

pub struct TypeId {
    pub name: String,
}

A nominal type’s identity: a name, and nothing else.

#[prebindgen] names live in one flat namespace — a duplicate is a ParseError — so the name is the whole address. It deliberately carries no crate: a reference carries a name, and the declaring crate belongs to the declaration, reachable by looking the name up among the elements. Putting the use site’s crate here would make the same type compare unequal to itself across two source crates.

A name rather than a syn::Path on purpose: an identity kept as syntax makes every consumer take a path apart to learn what a type is, which is the re-classification issue #211 exists to stop.

Fields

name: String

The path as written, minus any generic arguments — Foo, foreign::Option. Normalized, so a reducible std or source-module path has already collapsed to its final segment.

A String, so a raw identifier is stored the way Ident prints it — r#type, hashes and all. Recover it with Self::ident rather than Ident::new, which rejects that spelling.

Implementations

impl TypeId

pub fn ident(&self) -> Option<Ident>

This name as an identifier, raw forms included.

Ident::new("r#type", …) panics — it takes a bare name, not a spelling — so a consumer rebuilding an ident from Self::name has to parse rather than construct. Here so that recovery is written once: the caller that gets it wrong does not fail until a source happens to use a keyword, which is exactly the kind of bug that ships.

None for a name that is not a single identifier at all (a path-qualified foreign::Option), which is the same answer bare_path_ident gave for one.

Trait Implementations

impl Clone for TypeId

fn clone(&self) -> TypeId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeId

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

Formats the value using the given formatter.

impl Eq for TypeId

impl PartialEq for TypeId

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TypeId