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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
use std::fmt::{self, Write};
use crate::docs::Docs;
use crate::formatter::Formatter;
use crate::function::Function;
use crate::scope::Scope;
use crate::r#enum::Enum;
use crate::r#impl::Impl;
use crate::r#struct::Struct;
use crate::r#trait::Trait;
/// Defines a module.
#[derive(Debug, Clone)]
pub struct Module {
/// Module name
pub name: String,
/// Visibility
vis: Option<String>,
/// Module documentation
docs: Option<Docs>,
/// Contents of the module
scope: Scope,
}
impl Module {
/// Return a new, blank module
pub fn new(name: &str) -> Self {
Self {
name: name.to_string(),
vis: None,
docs: None,
scope: Scope::new(),
}
}
/// Returns a mutable reference to the module's scope.
pub fn scope(&mut self) -> &mut Scope {
&mut self.scope
}
/// Set the module visibility.
pub fn vis(&mut self, vis: &str) -> &mut Self {
self.vis = Some(vis.to_string());
self
}
/// Import a type into the module's scope.
///
/// This results in a new `use` statement bein added to the beginning of the
/// module.
pub fn import(&mut self, path: &str, ty: &str) -> &mut Self {
self.scope.import(path, ty);
self
}
/// Push a new module definition, returning a mutable reference to it.
///
/// # Panics
///
/// Since a module's name must uniquely identify it within the scope in
/// which it is defined, pushing a module whose name is already defined
/// in this scope will cause this function to panic.
///
/// In many cases, the [`get_or_new_module`] function is preferrable, as it
/// will return the existing definition instead.
///
/// [`get_or_new_module`]: #method.get_or_new_module
pub fn new_module(&mut self, name: &str) -> &mut Self {
self.scope.new_module(name)
}
/// Returns a reference to a module if it is exists in this scope.
pub fn get_module<Q: ?Sized>(&self, name: &Q) -> Option<&Self>
where
String: PartialEq<Q>,
{
self.scope.get_module(name)
}
/// Returns a mutable reference to a module if it is exists in this scope.
pub fn get_module_mut<Q: ?Sized>(&mut self, name: &Q) -> Option<&mut Self>
where
String: PartialEq<Q>,
{
self.scope.get_module_mut(name)
}
/// Returns a mutable reference to a module, creating it if it does
/// not exist.
pub fn get_or_new_module(&mut self, name: &str) -> &mut Self {
self.scope.get_or_new_module(name)
}
/// Push a module definition.
///
/// # Panics
///
/// Since a module's name must uniquely identify it within the scope in
/// which it is defined, pushing a module whose name is already defined
/// in this scope will cause this function to panic.
///
/// In many cases, the [`get_or_new_module`] function is preferrable, as it will
/// return the existing definition instead.
///
/// [`get_or_new_module`]: #method.get_or_new_module
pub fn push_module(&mut self, item: Self) -> &mut Self {
self.scope.push_module(item);
self
}
/// Push a new struct definition, returning a mutable reference to it.
pub fn new_struct(&mut self, name: &str) -> &mut Struct {
self.scope.new_struct(name)
}
/// Push a structure definition
pub fn push_struct(&mut self, item: Struct) -> &mut Self {
self.scope.push_struct(item);
self
}
/// Push a new function definition, returning a mutable reference to it.
pub fn new_fn(&mut self, name: &str) -> &mut Function {
self.scope.new_fn(name)
}
/// Push a function definition
pub fn push_fn(&mut self, item: Function) -> &mut Self {
self.scope.push_fn(item);
self
}
/// Push a new enum definition, returning a mutable reference to it.
pub fn new_enum(&mut self, name: &str) -> &mut Enum {
self.scope.new_enum(name)
}
/// Push an enum definition
pub fn push_enum(&mut self, item: Enum) -> &mut Self {
self.scope.push_enum(item);
self
}
/// Push a new `impl` block, returning a mutable reference to it.
pub fn new_impl(&mut self, target: &str) -> &mut Impl {
self.scope.new_impl(target)
}
/// Push an `impl` block.
pub fn push_impl(&mut self, item: Impl) -> &mut Self {
self.scope.push_impl(item);
self
}
/// Push a trait definition
pub fn push_trait(&mut self, item: Trait) -> &mut Self {
self.scope.push_trait(item);
self
}
/// Formats the module using the given formatter.
pub fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
if let Some(ref vis) = self.vis {
write!(fmt, "{} ", vis)?;
}
write!(fmt, "mod {}", self.name)?;
fmt.block(|fmt| self.scope.fmt(fmt))
}
}