pick better names · nandi.uk/gleam@832ebf8

+45 -74

1 changed file

Expand all

compiler-core

src

parse.rs

+45 -74

compiler-core/src/parse.rs

View file

··· 255 255 } 256 256 257 257 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); 259 259 let definitions = self.ensure_no_errors_or_remaining_input(definitions)?; 260 260 let module = Module { 261 261 name: "".into(), ··· 613 613 self.advance(); 614 614 let _ = self 615 615 .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))?; 619 618 let (_, end) = 620 619 self.expect_one_following_series(&Token::RightParen, "an expression")?; 621 620 UntypedExpr::Tuple { ··· 732 731 // BitArray 733 732 Some((start, Token::LtLt, _)) => { 734 733 self.advance(); 735 - let segments = Parser::series_of( 736 - self, 737 - &|s| { 734 + let segments = self.series_of( 735 + &|this| { 738 736 Parser::parse_bit_array_segment( 739 - s, 737 + this, 740 738 &(|this| this.parse_expression_unit(ExpressionUnitContext::Other)), 741 739 &Parser::expect_expression, 742 740 &bit_array_expr_int, ··· 793 791 // case 794 792 Some((start, Token::Case, case_e)) => { 795 793 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))?; 798 795 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)?; 800 797 let (_, end) = 801 798 self.expect_one_following_series(&Token::RightBrace, "a case clause")?; 802 799 if subjects.is_empty() { ··· 978 975 }; 979 976 let mut arguments = vec![]; 980 977 if self.maybe_one(&Token::Comma).is_some() { 981 - arguments = Parser::series_of( 982 - self, 978 + arguments = self.series_of( 983 979 &Parser::parse_record_update_arg, 984 980 Some(&Token::Comma), 985 981 )?; ··· 1033 1029 Some((_, Token::LArrow, _)) => { 1034 1030 vec![] 1035 1031 } 1036 - _ => Parser::series_of(self, &Parser::parse_use_assignment, Some(&Token::Comma))?, 1032 + _ => self.series_of(&Parser::parse_use_assignment, Some(&Token::Comma))?, 1037 1033 }; 1038 1034 1039 1035 _ = self.expect_one_following_series(&Token::LArrow, "a use variable assignment")?; ··· 1482 1478 Some((start, Token::Hash, _)) => { 1483 1479 self.advance(); 1484 1480 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))?; 1490 1483 let (_, end) = self.expect_one_following_series(&Token::RightParen, "a pattern")?; 1491 1484 Pattern::Tuple { 1492 1485 location: SrcSpan { start, end }, ··· 1496 1489 // BitArray 1497 1490 Some((start, Token::LtLt, _)) => { 1498 1491 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) { 1505 1496 Ok(Some(Pattern::BitArray { location, .. })) => { 1506 1497 parse_error(ParseErrorType::NestedBitArrayPattern, location) 1507 1498 } ··· 1549 1540 if self.maybe_one(&Token::Comma).is_some() { 1550 1541 // See if there's a list of items after the tail, 1551 1542 // like `[..wibble, wobble, wabble]` 1552 - let elements = Parser::series_of( 1553 - self, 1543 + let elements = self.series_of( 1554 1544 &|this| this.parse_pattern(position), 1555 1545 Some(&Token::Comma), 1556 1546 ); ··· 1690 1680 let guard = self.parse_case_clause_guard()?; 1691 1681 let (arr_s, arr_e) = self 1692 1682 .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))?; 1694 1684 let then = self.parse_expression()?; 1695 1685 match then { 1696 1686 Some(then) => Ok(Some(Clause { ··· 1727 1717 &mut self, 1728 1718 position: PatternPosition, 1729 1719 ) -> 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)) 1735 1721 } 1736 1722 1737 1723 // examples: ··· 1829 1815 end: l_paren_end, 1830 1816 }, 1831 1817 ) 1832 - .map_err(|e| self.add_multi_line_clause_hint(e)); 1818 + .map_err(|error| self.add_multi_line_clause_hint(error)); 1833 1819 } 1834 1820 1835 1821 Ok(()) ··· 2217 2203 } 2218 2204 let _ = self 2219 2205 .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))?; 2226 2209 let (_, rpar_e) = 2227 2210 self.expect_one_following_series(&Token::RightParen, "a function parameter")?; 2228 2211 ··· 2448 2431 // a: _, expr 2449 2432 // a: expr, _, b: _ 2450 2433 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)) 2453 2435 } 2454 2436 2455 2437 // Parse a single function call arg ··· 2587 2569 } 2588 2570 2589 2571 let constructors = self.series_of( 2590 - &|parser| parser.parse_record_constructor(), 2572 + &|this| this.parse_record_constructor(), 2591 2573 // No separator 2592 2574 None, 2593 2575 )?; ··· 2717 2699 name_end: u32, 2718 2700 ) -> ParseError { 2719 2701 let fields = self.series_of( 2720 - &|parser| parser.parse_record_constructor_field(), 2702 + &|this| this.parse_record_constructor_field(), 2721 2703 Some(&Token::Comma), 2722 2704 ); 2723 2705 ··· 2770 2752 &mut self, 2771 2753 ) -> Result<(Vec<RecordConstructorArg<()>>, u32), ParseError> { 2772 2754 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(), 2776 2757 Some(&Token::Comma), 2777 2758 )?; 2778 2759 let (_, end) = self ··· 2788 2769 ) -> Result<Option<RecordConstructorArg<()>>, ParseError> { 2789 2770 match (self.tok0.take(), self.tok1.take()) { 2790 2771 (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(); 2793 2774 let doc = self.take_documentation(start); 2794 - match Parser::parse_type(self)? { 2775 + match self.parse_type()? { 2795 2776 Some(type_ast) => { 2796 2777 let end = type_ast.location().end; 2797 2778 Ok(Some(RecordConstructorArg { ··· 2808 2789 (t0, t1) => { 2809 2790 self.tok0 = t0; 2810 2791 self.tok1 = t1; 2811 - match Parser::parse_type(self)? { 2792 + match self.parse_type()? { 2812 2793 Some(type_ast) => { 2813 2794 let doc = match &self.tok0 { 2814 2795 Some((start, _, _)) => self.take_documentation(*start), ··· 2837 2818 ) -> Result<(u32, EcoString, Vec<SpannedString>, u32, u32), ParseError> { 2838 2819 let (start, upname, end) = self.expect_upname()?; 2839 2820 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))?; 2842 2822 let (_, par_e) = self.expect_one_following_series(&Token::RightParen, "a name")?; 2843 2823 if arguments.is_empty() { 2844 2824 return parse_error( ··· 2852 2832 .collect(); 2853 2833 Ok((start, upname, arguments2, par_e, end)) 2854 2834 } 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| 2858 2837 // Permit either names (`a`) or upnames (`A`) in this error-handling mode, 2859 2838 // as upnames are common in other languages. Convert to lowercase so the 2860 2839 // 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()) 2863 2842 .map(|(_, name, _)| name.to_lowercase())), 2864 2843 Some(&Token::Comma), 2865 2844 )?; ··· 2933 2912 Some((start, Token::Fn, _)) => { 2934 2913 self.advance(); 2935 2914 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))?; 2938 2916 let _ = self.expect_one_following_series(&Token::RightParen, "a type")?; 2939 2917 let (arr_s, arr_e) = self.expect_one(&Token::RArrow)?; 2940 2918 let return_ = self.parse_type()?; ··· 3082 3060 3083 3061 // For parsing a comma separated "list" of types, for tuple, constructor, and function 3084 3062 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))?; 3086 3064 Ok(elements) 3087 3065 } 3088 3066 ··· 3395 3373 Some((start, Token::Hash, _)) => { 3396 3374 self.advance(); 3397 3375 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))?; 3400 3377 let (_, end) = 3401 3378 self.expect_one_following_series(&Token::RightParen, "a constant value")?; 3402 3379 Ok(Some(Constant::Tuple { ··· 3512 3489 // BitArray 3513 3490 Some((start, Token::LtLt, _)) => { 3514 3491 self.advance(); 3515 - let segments = Parser::series_of( 3516 - self, 3492 + let segments = self.series_of( 3517 3493 &|this| { 3518 3494 this.parse_bit_array_segment( 3519 3495 &Parser::parse_const_value, ··· 3678 3654 3679 3655 let mut update_arguments = vec![]; 3680 3656 if self.maybe_one(&Token::Comma).is_some() { 3681 - update_arguments = Parser::series_of( 3682 - self, 3657 + update_arguments = self.series_of( 3683 3658 &Parser::parse_const_record_update_arg, 3684 3659 Some(&Token::Comma), 3685 3660 )?; ··· 3703 3678 field_map: Inferred::Unknown, 3704 3679 })) 3705 3680 } 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))?; 3711 3683 3712 3684 let (_, par_e) = self.expect_one_following_series( 3713 3685 &Token::RightParen, ··· 3891 3863 match value_parser(self)? { 3892 3864 Some(value) => { 3893 3865 let options = if self.maybe_one(&Token::Colon).is_some() { 3894 - Parser::series_of( 3895 - self, 3866 + self.series_of( 3896 3867 &|this| this.parse_bit_array_option(&arg_parser, &to_int_segment), 3897 3868 Some(&Token::Minus), 3898 3869 )?

Configure Feed

Configure Feed