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
|
use crate::ast_emitter::AstEmitter;
use crate::emitter::EmitError;
use ast::source_atom_set::SourceAtomSetIndex;
/// Struct for emitting bytecode for a property where its name is string.
///
/// If the property name is a string representing a number, it is considered an
/// index. In this case, NamePropertyEmitter falls back internally to
/// IndexPropertyEmitter
pub struct NamePropertyEmitter<'a, F>
where
F: Fn(&mut AstEmitter) -> Result<(), EmitError>,
{
pub state: &'a mut ObjectEmitterState,
pub key: SourceAtomSetIndex,
pub value: F,
}
impl<'a, F> NamePropertyEmitter<'a, F>
where
F: Fn(&mut AstEmitter) -> Result<(), EmitError>,
{
pub fn emit(self, emitter: &mut AstEmitter) -> Result<(), EmitError> {
// [stack] OBJ
match self.to_property_index(emitter, self.key) {
Some(value) => {
IndexPropertyEmitter {
state: self.state,
key: value as f64,
value: self.value,
}
.emit(emitter)?;
// [stack] OBJ
}
None => {
let name_index = emitter.emit.get_atom_gcthing_index(self.key);
(self.value)(emitter)?;
// [stack] OBJ VALUE
emitter.emit.init_prop(name_index);
// [stack] OBJ
}
}
Ok(())
}
fn to_property_index(
&self,
emitter: &mut AstEmitter,
index: SourceAtomSetIndex,
) -> Option<u32> {
let s = emitter.compilation_info.atoms.get(index);
s.parse::<u32>().ok()
}
}
/// Struct for emitting bytecode for a property where its name is number.
pub struct IndexPropertyEmitter<'a, F>
where
F: Fn(&mut AstEmitter) -> Result<(), EmitError>,
{
pub state: &'a mut ObjectEmitterState,
pub key: f64,
pub value: F,
}
impl<'a, F> IndexPropertyEmitter<'a, F>
where
F: Fn(&mut AstEmitter) -> Result<(), EmitError>,
{
pub fn emit(self, emitter: &mut AstEmitter) -> Result<(), EmitError> {
// [stack] OBJ
emitter.emit.numeric(self.key);
// [stack] OBJ KEY
(self.value)(emitter)?;
// [stack] OBJ KEY VALUE
emitter.emit.init_elem();
// [stack] OBJ
Ok(())
}
}
/// Struct for emitting bytecode for a computed property.
pub struct ComputedPropertyEmitter<'a, F1, F2>
where
F1: Fn(&mut AstEmitter) -> Result<(), EmitError>,
F2: Fn(&mut AstEmitter) -> Result<(), EmitError>,
{
pub state: &'a mut ObjectEmitterState,
pub key: F1,
pub value: F2,
}
impl<'a, F1, F2> ComputedPropertyEmitter<'a, F1, F2>
where
F1: Fn(&mut AstEmitter) -> Result<(), EmitError>,
F2: Fn(&mut AstEmitter) -> Result<(), EmitError>,
{
pub fn emit(self, emitter: &mut AstEmitter) -> Result<(), EmitError> {
// [stack] OBJ
(self.key)(emitter)?;
// [stack] OBJ KEY
(self.value)(emitter)?;
// [stack] OBJ KEY VALUE
emitter.emit.init_elem();
// [stack] OBJ
Ok(())
}
}
/// No state so far.
struct ObjectEmitterStateInternal {}
/// Opaque struct that can be created only by ObjectEmitter.
/// This guarantees that *PropertyEmitter structs cannot be used outside
/// of ObjectEmitter callback.
pub struct ObjectEmitterState(ObjectEmitterStateInternal);
impl ObjectEmitterState {
fn new() -> Self {
Self(ObjectEmitterStateInternal {})
}
}
pub struct ObjectEmitter<'a, PropT, PropF>
where
PropF: Fn(&mut AstEmitter, &mut ObjectEmitterState, &PropT) -> Result<(), EmitError>,
{
pub properties: std::slice::Iter<'a, PropT>,
pub prop: PropF,
}
impl<'a, PropT, PropF> ObjectEmitter<'a, PropT, PropF>
where
PropF: Fn(&mut AstEmitter, &mut ObjectEmitterState, &PropT) -> Result<(), EmitError>,
{
pub fn emit(self, emitter: &mut AstEmitter) -> Result<(), EmitError> {
// [stack]
emitter.emit.new_init();
// [stack] OBJ
let mut state = ObjectEmitterState::new();
for prop in self.properties {
(self.prop)(emitter, &mut state, prop)?;
// [stack] OBJ
}
Ok(())
}
}
|
