Skip to content

Commit 4b84194

Browse files
giacomocavalierigiacomocavalieri
committed
pick better names
1 parent 41f1eea commit 4b84194

1 file changed

Lines changed: 45 additions & 74 deletions

File tree

‎compiler-core/src/parse.rs‎

Lines changed: 45 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -255,7 +255,7 @@ where
255255
}
256256

257257
fn parse_module(&mut self) -> Result<Parsed, ParseError> {
258-
let definitions = Parser::series_of(self, &Parser::parse_definition, None);
258+
let definitions = self.series_of(&Parser::parse_definition, None);
259259
let definitions = self.ensure_no_errors_or_remaining_input(definitions)?;
260260
let module = Module {
261261
name: "".into(),
@@ -613,9 +613,8 @@ where
613613
self.advance();
614614
let _ = self
615615
.expect_one(&Token::LeftParen)
616-
.map_err(|e| self.add_comment_style_hint(e))?;
617-
let elements =
618-
Parser::series_of(self, &Parser::parse_expression, Some(&Token::Comma))?;
616+
.map_err(|error| self.add_comment_style_hint(error))?;
617+
let elements = self.series_of(&Parser::parse_expression, Some(&Token::Comma))?;
619618
let (_, end) =
620619
self.expect_one_following_series(&Token::RightParen, "an expression")?;
621620
UntypedExpr::Tuple {
@@ -732,11 +731,10 @@ where
732731
// BitArray
733732
Some((start, Token::LtLt, _)) => {
734733
self.advance();
735-
let segments = Parser::series_of(
736-
self,
737-
&|s| {
734+
let segments = self.series_of(
735+
&|this| {
738736
Parser::parse_bit_array_segment(
739-
s,
737+
this,
740738
&(|this| this.parse_expression_unit(ExpressionUnitContext::Other)),
741739
&Parser::expect_expression,
742740
&bit_array_expr_int,
@@ -793,10 +791,9 @@ where
793791
// case
794792
Some((start, Token::Case, case_e)) => {
795793
self.advance();
796-
let subjects =
797-
Parser::series_of(self, &Parser::parse_expression, Some(&Token::Comma))?;
794+
let subjects = self.series_of(&Parser::parse_expression, Some(&Token::Comma))?;
798795
if self.maybe_one(&Token::LeftBrace).is_some() {
799-
let clauses = Parser::series_of(self, &Parser::parse_case_clause, None)?;
796+
let clauses = self.series_of(&Parser::parse_case_clause, None)?;
800797
let (_, end) =
801798
self.expect_one_following_series(&Token::RightBrace, "a case clause")?;
802799
if subjects.is_empty() {
@@ -978,8 +975,7 @@ where
978975
};
979976
let mut arguments = vec![];
980977
if self.maybe_one(&Token::Comma).is_some() {
981-
arguments = Parser::series_of(
982-
self,
978+
arguments = self.series_of(
983979
&Parser::parse_record_update_arg,
984980
Some(&Token::Comma),
985981
)?;
@@ -1033,7 +1029,7 @@ where
10331029
Some((_, Token::LArrow, _)) => {
10341030
vec![]
10351031
}
1036-
_ => Parser::series_of(self, &Parser::parse_use_assignment, Some(&Token::Comma))?,
1032+
_ => self.series_of(&Parser::parse_use_assignment, Some(&Token::Comma))?,
10371033
};
10381034

10391035
_ = self.expect_one_following_series(&Token::LArrow, "a use variable assignment")?;
@@ -1482,11 +1478,8 @@ where
14821478
Some((start, Token::Hash, _)) => {
14831479
self.advance();
14841480
let _ = self.expect_one(&Token::LeftParen)?;
1485-
let elements = Parser::series_of(
1486-
self,
1487-
&|this| this.parse_pattern(position),
1488-
Some(&Token::Comma),
1489-
)?;
1481+
let elements =
1482+
self.series_of(&|this| this.parse_pattern(position), Some(&Token::Comma))?;
14901483
let (_, end) = self.expect_one_following_series(&Token::RightParen, "a pattern")?;
14911484
Pattern::Tuple {
14921485
location: SrcSpan { start, end },
@@ -1496,12 +1489,10 @@ where
14961489
// BitArray
14971490
Some((start, Token::LtLt, _)) => {
14981491
self.advance();
1499-
let segments = Parser::series_of(
1500-
self,
1501-
&|s| {
1502-
Parser::parse_bit_array_segment(
1503-
s,
1504-
&|s| match s.parse_pattern(position) {
1492+
let segments = self.series_of(
1493+
&|this| {
1494+
this.parse_bit_array_segment(
1495+
&|this| match this.parse_pattern(position) {
15051496
Ok(Some(Pattern::BitArray { location, .. })) => {
15061497
parse_error(ParseErrorType::NestedBitArrayPattern, location)
15071498
}
@@ -1549,8 +1540,7 @@ where
15491540
if self.maybe_one(&Token::Comma).is_some() {
15501541
// See if there's a list of items after the tail,
15511542
// like `[..wibble, wobble, wabble]`
1552-
let elements = Parser::series_of(
1553-
self,
1543+
let elements = self.series_of(
15541544
&|this| this.parse_pattern(position),
15551545
Some(&Token::Comma),
15561546
);
@@ -1690,7 +1680,7 @@ where
16901680
let guard = self.parse_case_clause_guard()?;
16911681
let (arr_s, arr_e) = self
16921682
.expect_one(&Token::RArrow)
1693-
.map_err(|e| self.add_multi_line_clause_hint(e))?;
1683+
.map_err(|error| self.add_multi_line_clause_hint(error))?;
16941684
let then = self.parse_expression()?;
16951685
match then {
16961686
Some(then) => Ok(Some(Clause {
@@ -1727,11 +1717,7 @@ where
17271717
&mut self,
17281718
position: PatternPosition,
17291719
) -> Result<Vec<UntypedPattern>, ParseError> {
1730-
Parser::series_of(
1731-
self,
1732-
&|this| this.parse_pattern(position),
1733-
Some(&Token::Comma),
1734-
)
1720+
self.series_of(&|this| this.parse_pattern(position), Some(&Token::Comma))
17351721
}
17361722

17371723
// examples:
@@ -1829,7 +1815,7 @@ where
18291815
end: l_paren_end,
18301816
},
18311817
)
1832-
.map_err(|e| self.add_multi_line_clause_hint(e));
1818+
.map_err(|error| self.add_multi_line_clause_hint(error));
18331819
}
18341820

18351821
Ok(())
@@ -2217,12 +2203,9 @@ where
22172203
}
22182204
let _ = self
22192205
.expect_one(&Token::LeftParen)
2220-
.map_err(|e| self.add_anon_function_hint(e))?;
2221-
let arguments = Parser::series_of(
2222-
self,
2223-
&|parser| Parser::parse_fn_param(parser, is_anon),
2224-
Some(&Token::Comma),
2225-
)?;
2206+
.map_err(|error| self.add_anon_function_hint(error))?;
2207+
let arguments =
2208+
self.series_of(&|this| this.parse_fn_param(is_anon), Some(&Token::Comma))?;
22262209
let (_, rpar_e) =
22272210
self.expect_one_following_series(&Token::RightParen, "a function parameter")?;
22282211

@@ -2448,8 +2431,7 @@ where
24482431
// a: _, expr
24492432
// a: expr, _, b: _
24502433
fn parse_fn_arguments(&mut self) -> Result<Vec<ParserArg>, ParseError> {
2451-
let arguments = Parser::series_of(self, &Parser::parse_fn_argument, Some(&Token::Comma))?;
2452-
Ok(arguments)
2434+
self.series_of(&Parser::parse_fn_argument, Some(&Token::Comma))
24532435
}
24542436

24552437
// Parse a single function call arg
@@ -2587,7 +2569,7 @@ where
25872569
}
25882570

25892571
let constructors = self.series_of(
2590-
&|parser| parser.parse_record_constructor(),
2572+
&|this| this.parse_record_constructor(),
25912573
// No separator
25922574
None,
25932575
)?;
@@ -2717,7 +2699,7 @@ where
27172699
name_end: u32,
27182700
) -> ParseError {
27192701
let fields = self.series_of(
2720-
&|parser| parser.parse_record_constructor_field(),
2702+
&|this| this.parse_record_constructor_field(),
27212703
Some(&Token::Comma),
27222704
);
27232705

@@ -2770,9 +2752,8 @@ where
27702752
&mut self,
27712753
) -> Result<(Vec<RecordConstructorArg<()>>, u32), ParseError> {
27722754
if self.maybe_one(&Token::LeftParen).is_some() {
2773-
let arguments = Parser::series_of(
2774-
self,
2775-
&|parser| parser.parse_record_constructor_field(),
2755+
let arguments = self.series_of(
2756+
&|this| this.parse_record_constructor_field(),
27762757
Some(&Token::Comma),
27772758
)?;
27782759
let (_, end) = self
@@ -2788,10 +2769,10 @@ where
27882769
) -> Result<Option<RecordConstructorArg<()>>, ParseError> {
27892770
match (self.tok0.take(), self.tok1.take()) {
27902771
(Some((start, Token::Name { name }, name_end)), Some((_, Token::Colon, end))) => {
2791-
let _ = Parser::next_tok(self);
2792-
let _ = Parser::next_tok(self);
2772+
let _ = self.next_tok();
2773+
let _ = self.next_tok();
27932774
let doc = self.take_documentation(start);
2794-
match Parser::parse_type(self)? {
2775+
match self.parse_type()? {
27952776
Some(type_ast) => {
27962777
let end = type_ast.location().end;
27972778
Ok(Some(RecordConstructorArg {
@@ -2808,7 +2789,7 @@ where
28082789
(t0, t1) => {
28092790
self.tok0 = t0;
28102791
self.tok1 = t1;
2811-
match Parser::parse_type(self)? {
2792+
match self.parse_type()? {
28122793
Some(type_ast) => {
28132794
let doc = match &self.tok0 {
28142795
Some((start, _, _)) => self.take_documentation(*start),
@@ -2837,8 +2818,7 @@ where
28372818
) -> Result<(u32, EcoString, Vec<SpannedString>, u32, u32), ParseError> {
28382819
let (start, upname, end) = self.expect_upname()?;
28392820
if let Some((par_s, _)) = self.maybe_one(&Token::LeftParen) {
2840-
let arguments =
2841-
Parser::series_of(self, &|p| Ok(Parser::maybe_name(p)), Some(&Token::Comma))?;
2821+
let arguments = self.series_of(&|this| Ok(this.maybe_name()), Some(&Token::Comma))?;
28422822
let (_, par_e) = self.expect_one_following_series(&Token::RightParen, "a name")?;
28432823
if arguments.is_empty() {
28442824
return parse_error(
@@ -2852,14 +2832,13 @@ where
28522832
.collect();
28532833
Ok((start, upname, arguments2, par_e, end))
28542834
} else if let Some((less_start, less_end)) = self.maybe_one(&Token::Less) {
2855-
let mut arguments = Parser::series_of(
2856-
self,
2857-
&|p|
2835+
let mut arguments = self.series_of(
2836+
&|this|
28582837
// Permit either names (`a`) or upnames (`A`) in this error-handling mode,
28592838
// as upnames are common in other languages. Convert to lowercase so the
28602839
// example is correct whichever was used.
2861-
Ok(Parser::maybe_name(p)
2862-
.or_else(|| Parser::maybe_upname(p))
2840+
Ok(this.maybe_name()
2841+
.or_else(|| this.maybe_upname())
28632842
.map(|(_, name, _)| name.to_lowercase())),
28642843
Some(&Token::Comma),
28652844
)?;
@@ -2933,8 +2912,7 @@ where
29332912
Some((start, Token::Fn, _)) => {
29342913
self.advance();
29352914
let _ = self.expect_one(&Token::LeftParen)?;
2936-
let arguments =
2937-
Parser::series_of(self, &|x| Parser::parse_type(x), Some(&Token::Comma))?;
2915+
let arguments = self.series_of(&|this| this.parse_type(), Some(&Token::Comma))?;
29382916
let _ = self.expect_one_following_series(&Token::RightParen, "a type")?;
29392917
let (arr_s, arr_e) = self.expect_one(&Token::RArrow)?;
29402918
let return_ = self.parse_type()?;
@@ -3082,7 +3060,7 @@ where
30823060

30833061
// For parsing a comma separated "list" of types, for tuple, constructor, and function
30843062
fn parse_types(&mut self) -> Result<Vec<TypeAst>, ParseError> {
3085-
let elements = Parser::series_of(self, &|p| Parser::parse_type(p), Some(&Token::Comma))?;
3063+
let elements = self.series_of(&|this| this.parse_type(), Some(&Token::Comma))?;
30863064
Ok(elements)
30873065
}
30883066

@@ -3395,8 +3373,7 @@ where
33953373
Some((start, Token::Hash, _)) => {
33963374
self.advance();
33973375
let _ = self.expect_one(&Token::LeftParen)?;
3398-
let elements =
3399-
Parser::series_of(self, &Parser::parse_const_value, Some(&Token::Comma))?;
3376+
let elements = self.series_of(&Parser::parse_const_value, Some(&Token::Comma))?;
34003377
let (_, end) =
34013378
self.expect_one_following_series(&Token::RightParen, "a constant value")?;
34023379
Ok(Some(Constant::Tuple {
@@ -3512,8 +3489,7 @@ where
35123489
// BitArray
35133490
Some((start, Token::LtLt, _)) => {
35143491
self.advance();
3515-
let segments = Parser::series_of(
3516-
self,
3492+
let segments = self.series_of(
35173493
&|this| {
35183494
this.parse_bit_array_segment(
35193495
&Parser::parse_const_value,
@@ -3678,8 +3654,7 @@ where
36783654

36793655
let mut update_arguments = vec![];
36803656
if self.maybe_one(&Token::Comma).is_some() {
3681-
update_arguments = Parser::series_of(
3682-
self,
3657+
update_arguments = self.series_of(
36833658
&Parser::parse_const_record_update_arg,
36843659
Some(&Token::Comma),
36853660
)?;
@@ -3703,11 +3678,8 @@ where
37033678
field_map: Inferred::Unknown,
37043679
}))
37053680
} else {
3706-
let arguments = Parser::series_of(
3707-
self,
3708-
&Parser::parse_const_record_arg,
3709-
Some(&Token::Comma),
3710-
)?;
3681+
let arguments =
3682+
self.series_of(&Parser::parse_const_record_arg, Some(&Token::Comma))?;
37113683

37123684
let (_, par_e) = self.expect_one_following_series(
37133685
&Token::RightParen,
@@ -3891,8 +3863,7 @@ where
38913863
match value_parser(self)? {
38923864
Some(value) => {
38933865
let options = if self.maybe_one(&Token::Colon).is_some() {
3894-
Parser::series_of(
3895-
self,
3866+
self.series_of(
38963867
&|this| this.parse_bit_array_option(&arg_parser, &to_int_segment),
38973868
Some(&Token::Minus),
38983869
)?

0 commit comments

Comments
 (0)