rust-analyzer-modules 0.1.0

A library for analyzing a Rust crate's module structure and dependencies (fork with rust-analyzer 0.0.289 support).
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

use ra_ap_hir::{self as hir};
use ra_ap_ide::{self as ide};

use crate::analyzer;

pub(crate) use self::{
    attr::{ItemAttrs, ItemCfgAttr, ItemTestAttr},
    kind_display_name::ItemKindDisplayName,
    visibility::ItemVisibility,
};

mod attr;
mod kind_display_name;
mod visibility;

#[derive(Clone, PartialEq, Debug)]
pub struct Item {
    pub hir: hir::ModuleDef,
}

impl Item {
    pub fn new(hir: hir::ModuleDef) -> Self {
        Self { hir }
    }

    pub fn visibility(&self, db: &ide::RootDatabase, edition: ide::Edition) -> ItemVisibility {
        ItemVisibility::new(self.hir, db, edition)
    }

    pub fn attrs(&self, db: &ide::RootDatabase, _edition: ide::Edition) -> ItemAttrs {
        ItemAttrs::new(self, db)
    }

    pub fn kind_display_name(
        &self,
        db: &ide::RootDatabase,
        _edition: ide::Edition,
    ) -> ItemKindDisplayName {
        ItemKindDisplayName::new(self, db)
    }

    pub fn display_name(&self, db: &ide::RootDatabase, edition: ide::Edition) -> String {
        analyzer::display_name(self.hir, db, edition)
    }

    pub fn display_path(&self, db: &ide::RootDatabase, edition: ide::Edition) -> String {
        analyzer::display_path(self.hir, db, edition)
    }

    pub fn kind_ordering(&self, _db: &ide::RootDatabase, _edition: ide::Edition) -> u8 {
        // Return ordering based on item kind for sorting
        // Lower numbers come first
        match self.hir {
            hir::ModuleDef::Module(_) => 0,
            hir::ModuleDef::Trait(_) => 1,
            hir::ModuleDef::TraitAlias(_) => 2,
            hir::ModuleDef::Adt(adt) => match adt {
                hir::Adt::Struct(_) => 3,
                hir::Adt::Enum(_) => 4,
                hir::Adt::Union(_) => 5,
            },
            hir::ModuleDef::Variant(_) => 6,
            hir::ModuleDef::Const(_) => 7,
            hir::ModuleDef::Static(_) => 8,
            hir::ModuleDef::Function(_) => 9,
            hir::ModuleDef::TypeAlias(_) => 10,
            hir::ModuleDef::BuiltinType(_) => 11,
            hir::ModuleDef::Macro(_) => 12,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_item_creation() {
        // We can't create a real ModuleDef without a database, but we can test the struct
        // This is more of a compile-time test to ensure the API is correct
        let _ = |hir: hir::ModuleDef| {
            let item = Item::new(hir);
            assert!(matches!(item.hir, _));
        };
    }

    #[test]
    fn test_kind_ordering() {
        // Test that kind ordering returns expected values
        let _ = |item: &Item, db: &ide::RootDatabase, edition: ide::Edition| {
            let ordering = item.kind_ordering(db, edition);
            match item.hir {
                hir::ModuleDef::Module(_) => assert_eq!(ordering, 0),
                hir::ModuleDef::Trait(_) => assert_eq!(ordering, 1),
                hir::ModuleDef::TraitAlias(_) => assert_eq!(ordering, 2),
                hir::ModuleDef::Adt(adt) => match adt {
                    hir::Adt::Struct(_) => assert_eq!(ordering, 3),
                    hir::Adt::Enum(_) => assert_eq!(ordering, 4),
                    hir::Adt::Union(_) => assert_eq!(ordering, 5),
                },
                hir::ModuleDef::Variant(_) => assert_eq!(ordering, 6),
                hir::ModuleDef::Const(_) => assert_eq!(ordering, 7),
                hir::ModuleDef::Static(_) => assert_eq!(ordering, 8),
                hir::ModuleDef::Function(_) => assert_eq!(ordering, 9),
                hir::ModuleDef::TypeAlias(_) => assert_eq!(ordering, 10),
                hir::ModuleDef::BuiltinType(_) => assert_eq!(ordering, 11),
                hir::ModuleDef::Macro(_) => assert_eq!(ordering, 12),
            }
        };
    }

    #[test]
    fn test_item_equality() {
        // Items should be equal if they have the same HIR
        let _ = |hir1: hir::ModuleDef, hir2: hir::ModuleDef| {
            let item1 = Item::new(hir1);
            let item2 = Item::new(hir2);

            if hir1 == hir2 {
                assert_eq!(item1, item2);
            } else {
                assert_ne!(item1, item2);
            }
        };
    }
}