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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
//! Name resolution algorithm
use rustc_hash::FxHashMap;
use ra_syntax::{
SmolStr, SyntaxKind,
ast::{self, NameOwner}
};
use crate::{
descriptors::module::ModuleId,
syntax_ptr::LocalSyntaxPtr,
};
/// A set of items and imports declared inside a module, without relation to
/// other modules.
///
/// This stands in-between raw syntax and name resolution and alow us to avoid
/// recomputing name res: if `InputModuleItems` are the same, we can avoid
/// running name resolution.
#[derive(Debug, Default)]
struct InputModuleItems {
items: Vec<ModuleItem>,
glob_imports: Vec<Path>,
imports: Vec<Path>,
}
#[derive(Debug, Clone)]
struct Path {
kind: PathKind,
segments: Vec<SmolStr>,
}
#[derive(Debug, Clone, Copy)]
enum PathKind {
Abs,
Self_,
Super,
Crate,
}
#[derive(Debug)]
struct ItemMap {
per_module: FxHashMap<ModuleId, ModuleItems>,
}
#[derive(Debug)]
struct ModuleItems {
items: FxHashMap<SmolStr, PerNs<ModuleItem>>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum Namespace {
Types,
Values,
}
#[derive(Debug)]
struct PerNs<T> {
types: Option<T>,
values: Option<T>,
}
#[derive(Debug)]
struct ModuleItem {
ptr: LocalSyntaxPtr,
name: SmolStr,
kind: SyntaxKind,
vis: Vis,
}
#[derive(Debug)]
enum Vis {
Priv,
Other,
}
impl InputModuleItems {
fn new<'a>(items: impl Iterator<Item = ast::ModuleItem<'a>>) -> InputModuleItems {
let mut res = InputModuleItems::default();
for item in items {
res.add_item(item);
}
res
}
fn add_item(&mut self, item: ast::ModuleItem) -> Option<()> {
match item {
ast::ModuleItem::StructDef(it) => self.items.push(ModuleItem::new(it)?),
ast::ModuleItem::EnumDef(it) => self.items.push(ModuleItem::new(it)?),
ast::ModuleItem::FnDef(it) => self.items.push(ModuleItem::new(it)?),
ast::ModuleItem::TraitDef(it) => self.items.push(ModuleItem::new(it)?),
ast::ModuleItem::TypeDef(it) => self.items.push(ModuleItem::new(it)?),
ast::ModuleItem::ImplItem(it) => {
// impls don't define items
}
ast::ModuleItem::UseItem(it) => self.add_use_item(it),
ast::ModuleItem::ExternCrateItem(it) => (),
ast::ModuleItem::ConstDef(it) => self.items.push(ModuleItem::new(it)?),
ast::ModuleItem::StaticDef(it) => self.items.push(ModuleItem::new(it)?),
ast::ModuleItem::Module(it) => self.items.push(ModuleItem::new(it)?),
}
Some(())
}
fn add_use_item(&mut self, item: ast::UseItem) {
if let Some(tree) = item.use_tree() {
self.add_use_tree(None, tree);
}
}
fn add_use_tree(&mut self, prefix: Option<Path>, tree: ast::UseTree) {
if let Some(use_tree_list) = tree.use_tree_list() {
let prefix = match tree.path() {
None => prefix,
Some(path) => match convert_path(prefix, path) {
Some(it) => Some(it),
None => return, // TODO: report errors somewhere
},
};
for tree in use_tree_list.use_trees() {
self.add_use_tree(prefix.clone(), tree);
}
} else {
if let Some(path) = tree.path() {
if let Some(path) = convert_path(prefix, path) {
if tree.has_star() {
&mut self.glob_imports
} else {
&mut self.imports
}
.push(path);
}
}
}
}
}
fn convert_path(prefix: Option<Path>, path: ast::Path) -> Option<Path> {
prefix
}
impl ModuleItem {
fn new<'a>(item: impl ast::NameOwner<'a>) -> Option<ModuleItem> {
let name = item.name()?.text();
let ptr = LocalSyntaxPtr::new(item.syntax());
let kind = item.syntax().kind();
let vis = Vis::Other;
let res = ModuleItem {
ptr,
name,
kind,
vis,
};
Some(res)
}
}
|
