Struct Import 

pub struct Import {
    pub module: String,
    pub relative_dots: u8,
    pub names: Vec<String>,
    pub bindings: Vec<String>,
    pub is_star: bool,
    pub type_checking_only: bool,
    pub redundant: Vec<bool>,
    pub in_try: bool,
    pub line: u32,
    pub end_line: u32,
}

An import / from ... import ... statement.

Fields

module: String

The module path, e.g. os.path or mypkg.sub. Empty for relative dots captured in relative_dots.

relative_dots: u8

Number of leading dots in a relative import (from . import x -> 1).

names: Vec<String>

Imported names (from m import a, b -> [a, b]). Empty for import m.

bindings: Vec<String>

Local names this statement binds, honoring aliases: import a.b -> [a]; import a.b as c -> [c]; from m import x as y -> [y]. Empty for *.

is_star: bool

True for from m import *.

type_checking_only: bool

True if guarded by if TYPE_CHECKING: / if False: — a deliberate type-only import that must never be flagged as unused.

redundant: Vec<bool>

Per-binding: true when written with a redundant alias (import x as x, from m import y as y) — the PEP 484 explicit re-export convention, so the binding is public API even with zero in-module uses.

in_try: bool

True if the statement sits in a try: body / except: handler, or a module-level if/else arm — availability probes and platform switches (try: import x / except: …, if flag: from y import z). Removing a guarded arm changes behavior, so this is never a certain fix.

line: u32

end_line: u32

Last line of the statement (inclusive) — multi-line from x import (…) spans several lines, and a # noqa on any of them counts.

Trait Implementations

impl Clone for Import

fn clone(&self) -> Import

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Import

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

Formats the value using the given formatter.

impl Eq for Import

impl PartialEq for Import

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