pedant-core 0.20.2

Analysis engine for pedant: IR extraction, style checks, and capability detection
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! The module-instance view: where one unit's modules live and how they nest.
//!
//! An instance is unit-local. The same source may be instantiated under two
//! units, or twice inside one unit through separate `#[path]` declarations, and
//! each occurrence is its own instance.

use std::fmt;
use std::sync::Arc;

/// Opaque identity of one module instance inside a single resolution unit.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RustModuleId {
    index: u32,
}

impl RustModuleId {
    /// Issue an identity for the module instance at `index`.
    pub(super) fn new(index: u32) -> Self {
        Self { index }
    }

    /// The unit-local index this identity selects.
    pub(in crate::resolution::rust) fn index(&self) -> u32 {
        self.index
    }
}

impl fmt::Debug for RustModuleId {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "RustModuleId({})", self.index)
    }
}

/// One module instance: its place in the unit's module tree and the source
/// whose items it owns.
#[derive(Debug)]
pub struct RustModuleInstance {
    pub(super) id: RustModuleId,
    pub(super) parent: Option<RustModuleId>,
    pub(super) name: Arc<str>,
    pub(super) path: Arc<str>,
    pub(super) inline: bool,
    pub(super) depth: u32,
    /// Which lexical scope of [`Self::path`] this instance holds.
    pub(in crate::resolution::rust) scope: u32,
    /// This instance's position in the declaring source's IR declaration
    /// table; absent for a unit's crate root.
    pub(in crate::resolution::rust) declaration: Option<u32>,
}

impl RustModuleInstance {
    /// This instance's unit-local identity.
    pub fn id(&self) -> RustModuleId {
        self.id
    }

    /// The instance that declares this one; absent for the crate root.
    pub fn parent(&self) -> Option<RustModuleId> {
        self.parent
    }

    /// The declared module name; `crate` for the root instance.
    pub fn name(&self) -> &str {
        &self.name
    }

    /// The repository-relative source holding this instance's items.
    pub fn path(&self) -> &str {
        &self.path
    }

    /// Whether the parent source declares this module inline.
    pub fn is_inline(&self) -> bool {
        self.inline
    }

    /// Module nesting depth below the crate root, which is zero.
    pub fn depth(&self) -> u32 {
        self.depth
    }
}