Struct rustc_resolve::imports::ImportData

source ·

pub(crate) struct ImportData<'a> {
    pub kind: ImportKind<'a>,
    pub root_id: NodeId,
    pub use_span: Span,
    pub use_span_with_attributes: Span,
    pub has_attributes: bool,
    pub span: Span,
    pub root_span: Span,
    pub parent_scope: ParentScope<'a>,
    pub module_path: Vec<Segment>,
    pub imported_module: Cell<Option<ModuleOrUniformRoot<'a>>>,
    pub vis: Cell<Option<Visibility>>,
    pub used: Cell<Option<Used>>,
}

Expand description

One import.

Fields§

§kind: ImportKind<'a>§root_id: NodeId

Node ID of the “root” use item – this is always the same as ImportKind’s id (if it exists) except in the case of “nested” use trees, in which case it will be the ID of the root use tree. e.g., in the example

use foo::bar::{a, b}

this would be the ID of the use foo::bar UseTree node. In case of imports without their own node ID it’s the closest node that can be used, for example, for reporting lints.

§use_span: Span

Span of the entire use statement.

§use_span_with_attributes: Span

Span of the entire use statement with attributes.

§has_attributes: bool

Did the use statement have any attributes?

§span: Span

Span of this use tree.

§root_span: Span

Span of the root use tree (see root_id).

§parent_scope: ParentScope<'a>§module_path: Vec<Segment>§imported_module: Cell<Option<ModuleOrUniformRoot<'a>>>

The resolution of module_path.

§vis: Cell<Option<Visibility>>§used: Cell<Option<Used>>

Struct rustc_resolve::imports::ImportData

Fields§

Implementations§

impl<'a> ImportData<'a>

pub(crate) fn is_glob(&self) -> bool

pub(crate) fn is_nested(&self) -> bool

pub(crate) fn expect_vis(&self) -> Visibility

pub(crate) fn id(&self) -> Option<NodeId>

fn simplify(&self, r: &Resolver<'_, '_>) -> Reexport

Trait Implementations§

impl<'a> Clone for ImportData<'a>

fn clone(&self) -> ImportData<'a>

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

impl<'a> Debug for ImportData<'a>

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

Auto Trait Implementations§

impl<'a> !DynSend for ImportData<'a>

impl<'a> !DynSync for ImportData<'a>

impl<'a> !Freeze for ImportData<'a>

impl<'a> !RefUnwindSafe for ImportData<'a>

impl<'a> !Send for ImportData<'a>

impl<'a> !Sync for ImportData<'a>

impl<'a> Unpin for ImportData<'a>

impl<'a> !UnwindSafe for ImportData<'a>

Blanket Implementations§

impl<T> Aligned for T

const ALIGN: Alignment = _

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T, R> CollectAndApply<T, R> for T

fn collect_and_apply<I, F>(iter: I, f: F) -> Rwhere I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

type Output = R

impl<T> Filterable for T

fn filterable( self, filter_name: &'static str ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<P> IntoQueryParam<P> for P

fn into_query_param(self) -> P

impl<T> MaybeResult<T> for T

type Error = !

fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

impl<T> Pointable for T

const ALIGN: usize = _

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<'tcx, T> ToPredicate<'tcx, T> for T

fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> T

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

fn vzip(self) -> V

impl<Tcx, T> Value<Tcx> for Twhere Tcx: DepContext,

default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed ) -> T

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

impl<'a, T> Captures<'a> for Twhere T: ?Sized,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

impl<'a, T> Captures<'a> for T
where T: ?Sized,

impl<T> ErasedDestructor for T
where T: 'static,