Skip to content

Commit c78860c

Browse files
giacomocavalierilpil
giacomocavalieri
authored and
lpil
committed
pick better names
1 parent 83a3914 commit c78860c

File tree

1 file changed

+79
-68
lines changed

1 file changed

+79
-68
lines changed

‎compiler-core/src/erlang/pattern.rs‎

Lines changed: 79 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -7,46 +7,46 @@ use crate::analyse::Inferred;
77
use super::*;
88

99
pub(super) fn to_doc<'a>(
10-
p: &'a TypedPattern,
11-
vars: &mut Vec<&'a str>,
12-
env: &mut Env<'a>,
10+
pattern: &'a TypedPattern,
11+
variables: &mut Vec<&'a str>,
12+
environment: &mut Env<'a>,
1313
guards: &mut Vec<Document<'a>>,
1414
) -> Document<'a> {
15-
print(p, vars, env, guards)
15+
print(pattern, variables, environment, guards)
1616
}
1717

1818
fn print<'a>(
19-
p: &'a TypedPattern,
20-
vars: &mut Vec<&'a str>,
21-
env: &mut Env<'a>,
19+
pattern: &'a TypedPattern,
20+
variables: &mut Vec<&'a str>,
21+
environment: &mut Env<'a>,
2222
guards: &mut Vec<Document<'a>>,
2323
) -> Document<'a> {
24-
match p {
25-
Pattern::Assign {
26-
name, pattern: p, ..
27-
} => {
28-
vars.push(name);
29-
print(p, vars, env, guards)
24+
match pattern {
25+
Pattern::Assign { name, pattern, .. } => {
26+
variables.push(name);
27+
print(pattern, variables, environment, guards)
3028
.append(" = ")
31-
.append(env.next_local_var_name(name))
29+
.append(environment.next_local_var_name(name))
3230
}
3331

3432
Pattern::List { elements, tail, .. } => {
35-
pattern_list(elements, tail.as_deref(), vars, env, guards)
33+
pattern_list(elements, tail.as_deref(), variables, environment, guards)
3634
}
3735

3836
Pattern::Discard { .. } => "_".to_doc(),
3937

4038
Pattern::BitArraySize(size) => match size {
4139
BitArraySize::Int { .. }
4240
| BitArraySize::Variable { .. }
43-
| BitArraySize::Block { .. } => bit_array_size(size, env),
44-
BitArraySize::BinaryOperator { .. } => bit_array_size(size, env).surround("(", ")"),
41+
| BitArraySize::Block { .. } => bit_array_size(size, environment),
42+
BitArraySize::BinaryOperator { .. } => {
43+
bit_array_size(size, environment).surround("(", ")")
44+
}
4545
},
4646

4747
Pattern::Variable { name, .. } => {
48-
vars.push(name);
49-
env.next_local_var_name(name)
48+
variables.push(name);
49+
environment.next_local_var_name(name)
5050
}
5151

5252
Pattern::Int { value, .. } => int(value),
@@ -59,7 +59,7 @@ fn print<'a>(
5959
arguments,
6060
constructor: Inferred::Known(PatternConstructor { name, .. }),
6161
..
62-
} => tag_tuple_pattern(name, arguments, vars, env, guards),
62+
} => tag_tuple_pattern(name, arguments, variables, environment, guards),
6363

6464
Pattern::Constructor {
6565
constructor: Inferred::Unknown,
@@ -68,14 +68,16 @@ fn print<'a>(
6868
panic!("Erlang generation performed with uninferred pattern constructor")
6969
}
7070

71-
Pattern::Tuple { elements, .. } => {
72-
tuple(elements.iter().map(|p| print(p, vars, env, guards)))
73-
}
71+
Pattern::Tuple { elements, .. } => tuple(
72+
elements
73+
.iter()
74+
.map(|pattern| print(pattern, variables, environment, guards)),
75+
),
7476

7577
Pattern::BitArray { segments, .. } => bit_array(
7678
segments
7779
.iter()
78-
.map(|s| pattern_segment(&s.value, &s.options, vars, env, guards)),
80+
.map(|s| pattern_segment(&s.value, &s.options, variables, environment, guards)),
7981
),
8082

8183
Pattern::StringPrefix {
@@ -86,8 +88,8 @@ fn print<'a>(
8688
} => {
8789
let right = match right_side_assignment {
8890
AssignName::Variable(right) => {
89-
vars.push(right);
90-
env.next_local_var_name(right)
91+
variables.push(right);
92+
environment.next_local_var_name(right)
9193
}
9294
AssignName::Discard(_) => "_".to_doc(),
9395
};
@@ -105,8 +107,8 @@ fn print<'a>(
105107
// to variables within the pattern, we first match the expected prefix length in
106108
// bytes, then use a guard clause to verify the content.
107109
//
108-
vars.push(left_name);
109-
let name = env.next_local_var_name(left_name);
110+
variables.push(left_name);
111+
let name = environment.next_local_var_name(left_name);
110112
guards.push(docvec![name.clone(), " =:= ", string(left_side_string)]);
111113
docvec![
112114
"<<",
@@ -134,7 +136,7 @@ fn print<'a>(
134136
}
135137
}
136138

137-
fn bit_array_size<'a>(size: &'a TypedBitArraySize, env: &mut Env<'a>) -> Document<'a> {
139+
fn bit_array_size<'a>(size: &'a TypedBitArraySize, environment: &mut Env<'a>) -> Document<'a> {
138140
match size {
139141
BitArraySize::Int { value, .. } => int(value),
140142
BitArraySize::Variable {
@@ -146,9 +148,9 @@ fn bit_array_size<'a>(size: &'a TypedBitArraySize, env: &mut Env<'a>) -> Documen
146148
.variant;
147149
match v {
148150
ValueConstructorVariant::ModuleConstant { literal, .. } => {
149-
const_inline(literal, env)
151+
const_inline(literal, environment)
150152
}
151-
_ => env.local_var_name(name),
153+
_ => environment.local_var_name(name),
152154
}
153155
}
154156
BitArraySize::BinaryOperator {
@@ -161,35 +163,37 @@ fn bit_array_size<'a>(size: &'a TypedBitArraySize, env: &mut Env<'a>) -> Documen
161163
IntOperator::Add => " + ",
162164
IntOperator::Subtract => " - ",
163165
IntOperator::Multiply => " * ",
164-
IntOperator::Divide => return bit_array_size_divide(left, right, "div", env),
166+
IntOperator::Divide => {
167+
return bit_array_size_divide(left, right, "div", environment);
168+
}
165169
IntOperator::Remainder => {
166-
return bit_array_size_divide(left, right, "rem", env);
170+
return bit_array_size_divide(left, right, "rem", environment);
167171
}
168172
};
169173

170174
docvec![
171-
bit_array_size(left, env),
175+
bit_array_size(left, environment),
172176
operator,
173-
bit_array_size(right, env)
177+
bit_array_size(right, environment)
174178
]
175179
}
176-
BitArraySize::Block { inner, .. } => bit_array_size(inner, env).surround("(", ")"),
180+
BitArraySize::Block { inner, .. } => bit_array_size(inner, environment).surround("(", ")"),
177181
}
178182
}
179183

180184
fn bit_array_size_divide<'a>(
181185
left: &'a TypedBitArraySize,
182186
right: &'a TypedBitArraySize,
183187
operator: &'static str,
184-
env: &mut Env<'a>,
188+
environment: &mut Env<'a>,
185189
) -> Document<'a> {
186190
if right.non_zero_compile_time_number() {
187-
return bit_array_size_operator(left, operator, right, env);
191+
return bit_array_size_operator(left, operator, right, environment);
188192
}
189193

190-
let left = bit_array_size(left, env);
191-
let right = bit_array_size(right, env);
192-
let denominator = env.next_local_var_name("gleam@denominator");
194+
let left = bit_array_size(left, environment);
195+
let right = bit_array_size(right, environment);
196+
let denominator = environment.next_local_var_name("gleam@denominator");
193197
let clauses = docvec![
194198
line(),
195199
"0 -> 0;",
@@ -205,62 +209,69 @@ fn bit_array_size_operator<'a>(
205209
left: &'a TypedBitArraySize,
206210
operator: &'static str,
207211
right: &'a TypedBitArraySize,
208-
env: &mut Env<'a>,
212+
environment: &mut Env<'a>,
209213
) -> Document<'a> {
210214
let left = match left {
211-
BitArraySize::BinaryOperator { .. } => bit_array_size(left, env).surround("(", ")"),
212-
_ => bit_array_size(left, env),
215+
BitArraySize::BinaryOperator { .. } => bit_array_size(left, environment).surround("(", ")"),
216+
_ => bit_array_size(left, environment),
213217
};
214218
let right = match right {
215-
BitArraySize::BinaryOperator { .. } => bit_array_size(right, env).surround("(", ")"),
216-
_ => bit_array_size(right, env),
219+
BitArraySize::BinaryOperator { .. } => {
220+
bit_array_size(right, environment).surround("(", ")")
221+
}
222+
_ => bit_array_size(right, environment),
217223
};
218224
binop_documents(left, operator, right)
219225
}
220226

221227
fn tag_tuple_pattern<'a>(
222228
name: &'a str,
223229
arguments: &'a [CallArg<TypedPattern>],
224-
vars: &mut Vec<&'a str>,
225-
env: &mut Env<'a>,
230+
variables: &mut Vec<&'a str>,
231+
environment: &mut Env<'a>,
226232
guards: &mut Vec<Document<'a>>,
227233
) -> Document<'a> {
228234
if arguments.is_empty() {
229235
atom_string(to_snake_case(name))
230236
} else {
231237
tuple(
232-
[atom_string(to_snake_case(name))]
233-
.into_iter()
234-
.chain(arguments.iter().map(|p| print(&p.value, vars, env, guards))),
238+
[atom_string(to_snake_case(name))].into_iter().chain(
239+
arguments
240+
.iter()
241+
.map(|argument| print(&argument.value, variables, environment, guards)),
242+
),
235243
)
236244
}
237245
}
238246

239247
fn pattern_segment<'a>(
240248
value: &'a TypedPattern,
241249
options: &'a [BitArrayOption<TypedPattern>],
242-
vars: &mut Vec<&'a str>,
243-
env: &mut Env<'a>,
250+
variables: &mut Vec<&'a str>,
251+
environment: &mut Env<'a>,
244252
guards: &mut Vec<Document<'a>>,
245253
) -> Document<'a> {
246254
let pattern_is_a_string_literal = matches!(value, Pattern::String { .. });
247255
let pattern_is_a_discard = matches!(value, Pattern::Discard { .. });
248256

249-
let vars = RefCell::new(vars);
257+
let variables = RefCell::new(variables);
250258
let guards = RefCell::new(guards);
251259

252-
let create_document = |env: &mut Env<'a>| match value {
260+
let create_document = |environment: &mut Env<'a>| match value {
253261
Pattern::String { value, .. } => string_inner(value).surround("\"", "\""),
254262
Pattern::Discard { .. }
255263
| Pattern::Variable { .. }
256264
| Pattern::Int { .. }
257-
| Pattern::Float { .. } => {
258-
print(value, &mut vars.borrow_mut(), env, &mut guards.borrow_mut())
259-
}
265+
| Pattern::Float { .. } => print(
266+
value,
267+
&mut variables.borrow_mut(),
268+
environment,
269+
&mut guards.borrow_mut(),
270+
),
260271

261272
Pattern::Assign { name, pattern, .. } => {
262-
vars.borrow_mut().push(name);
263-
let variable_name = env.next_local_var_name(name);
273+
variables.borrow_mut().push(name);
274+
let variable_name = environment.next_local_var_name(name);
264275

265276
match pattern.as_ref() {
266277
// In Erlang, assignment patterns inside bit arrays are not allowed. So instead of
@@ -303,11 +314,11 @@ fn pattern_segment<'a>(
303314
_ => panic!("Pattern segment match not recognised"),
304315
};
305316

306-
let size = |value: &'a TypedPattern, env: &mut Env<'a>| {
317+
let size = |value: &'a TypedPattern, environment: &mut Env<'a>| {
307318
Some(":".to_doc().append(print(
308319
value,
309-
&mut vars.borrow_mut(),
310-
env,
320+
&mut variables.borrow_mut(),
321+
environment,
311322
&mut guards.borrow_mut(),
312323
)))
313324
};
@@ -321,23 +332,23 @@ fn pattern_segment<'a>(
321332
unit,
322333
pattern_is_a_string_literal,
323334
pattern_is_a_discard,
324-
env,
335+
environment,
325336
)
326337
}
327338

328339
fn pattern_list<'a>(
329340
elements: &'a [TypedPattern],
330341
tail: Option<&'a TypedPattern>,
331-
vars: &mut Vec<&'a str>,
332-
env: &mut Env<'a>,
342+
variables: &mut Vec<&'a str>,
343+
environment: &mut Env<'a>,
333344
guards: &mut Vec<Document<'a>>,
334345
) -> Document<'a> {
335346
let elements = join(
336347
elements
337348
.iter()
338-
.map(|element| print(element, vars, env, guards)),
349+
.map(|element| print(element, variables, environment, guards)),
339350
break_(",", ", "),
340351
);
341-
let tail = tail.map(|tail| print(tail, vars, env, guards));
352+
let tail = tail.map(|tail| print(tail, variables, environment, guards));
342353
list(elements, tail)
343354
}

0 commit comments

Comments
 (0)