Struct TypeInfo 

pub struct TypeInfo {
    pub name: String,
    pub source_module: Option<ModuleRef>,
    pub import: HashSet<ImportRef>,
    pub type_refs: HashMap<String, TypeIdentifierRef>,
}

Type information for creating Python stub files annotated by PyStubType trait.

Fields

name: String

The Python type name.

source_module: Option<ModuleRef>

The module this type belongs to.

• None: Type has no source module (e.g., typing.Any, primitives, generic container types)
• Some(ModuleRef::Default): Type from current package’s default module
• Some(ModuleRef::Named(path)): Type from specific module (e.g., "package.sub_mod")

import: HashSet<ImportRef>

Python modules must be imported in the stub file.

For example, when name is typing.Sequence[int], import should contain typing. This makes it possible to use user-defined types in the stub file.

type_refs: HashMap<String, TypeIdentifierRef>

Track all type identifiers referenced in the name expression.

This enables context-aware qualification of identifiers within compound type expressions. For example, in typing.Optional[ClassA], we need to track that ClassA is from a specific module and qualify it appropriately based on the target module context.

• Key: bare identifier (e.g., “ClassA”)
• Value: TypeIdentifierRef containing module and import kind

Implementations

impl TypeInfo

pub fn none() -> Self

A None type annotation.

pub fn any() -> Self

A typing.Any type annotation.

pub fn list_of<T: PyStubType>() -> Self

A list[Type] type annotation.

pub fn set_of<T: PyStubType>() -> Self

A set[Type] type annotation.

pub fn dict_of<K: PyStubType, V: PyStubType>() -> Self

A dict[Type] type annotation.

pub fn builtin(name: &str) -> Self

A type annotation of a built-in type provided from builtins module, such as int, str, or float. Generic builtin types are also possible, such as dict[str, str].

pub fn unqualified(name: &str) -> Self

Unqualified type.

pub fn with_module(name: &str, module: ModuleRef) -> Self

A type annotation of a type that must be imported. The type name must be qualified with the module name:

pyo3_stub_gen::TypeInfo::with_module("pathlib.Path", "pathlib".into());

pub fn locally_defined(type_name: &str, module: ModuleRef) -> Self

A type defined in the PyO3 module.

• Types are referenced using fully qualified names to avoid symbol collision when used across modules.
• For example, if A is defined in package.submod1, it will be referenced as submod1.A when used in other modules.
• The module will be imported as from package import submod1.
• When used in the same module where it’s defined, it will be automatically de-qualified during stub generation.
• The source_module field tracks which module the type belongs to for future use.

pyo3_stub_gen::TypeInfo::locally_defined("A", "package.submod1".into());

pub fn qualified_name(&self, target_module: &str) -> String

Get the qualified name for use in a specific target module.

• If the type has no source module, returns the name as-is
• If the type is from the same module as the target, returns unqualified name
• If the type is from a different module, returns qualified name with module component

Examples

• Type A from “package.sub_mod” used in “package.sub_mod” -> “A”
• Type A from “package.sub_mod” used in “package.main_mod” -> “sub_mod.A”

pub fn is_same_module(&self, target_module: &str) -> bool

Check if this type is from the same module as the target module.

pub fn is_internal_to_package(&self, package_root: &str) -> bool

Check if this type is internal to the package (starts with package root).

pub fn qualified_for_module(&self, target_module: &str) -> String

Get the qualified name for use in a specific target module with context-aware rewriting.

This method handles compound type expressions by rewriting nested identifiers based on the type_refs tracking information. For example:

• typing.Optional[ClassA] becomes typing.Optional[sub_mod.ClassA] when ClassA is from a different module.

Arguments

• target_module - The module where this type will be used

Returns

The qualified type name string with identifiers properly qualified

pub fn resolve_default_module(&mut self, default_module_name: &str)

Resolve ModuleRef::Default to the actual module name. Called at runtime when default module name is known.

Trait Implementations

impl BitOr for TypeInfo

type Output = TypeInfo

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl Clone for TypeInfo

fn clone(&self) -> TypeInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeInfo

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

Formats the value using the given formatter.

impl Display for TypeInfo

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

Formats the value using the given formatter.

impl PartialEq for TypeInfo

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

impl StructuralPartialEq for TypeInfo