schala-lang/src/parsing/combinator.rs

@@ -74,7 +74,7 @@ fn tok<'a, O>(
 fn toknl<'a, O>(
     input_parser: impl Parser<Span<'a>, O, VerboseError<Span<'a>>>,
 ) -> impl FnMut(Span<'a>) -> IResult<Span<'a>, O, VerboseError<Span<'a>>> {
-    context("token/newline", preceded(pair(many0(tok(statement_delimiter)), ws0), input_parser))
+    context("token/newline", preceded(ws0, input_parser))
 }
 
 fn kw<'a>(keyword_str: &'static str) -> impl FnMut(Span<'a>) -> ParseResult<()> {
@@ -120,11 +120,11 @@ fn block_comment(input: Span) -> ParseResult<()> {
         }
     }
 
-    context("block-comment", value((), tuple((tag("/*"), inner_parser, tag("*/")))))(input)
+    context("Block-comment", value((), tuple((tag("/*"), inner_parser, tag("*/")))))(input)
 }
 
 fn statement_delimiter(input: Span) -> ParseResult<()> {
-    context("statement-delimiter", tok(alt((value((), line_ending), value((), char(';'))))))(input)
+    tok(alt((value((), line_ending), value((), char(';')))))(input)
 }
 
 pub fn program(input: Span) -> ParseResult<AST> {
@@ -329,20 +329,33 @@ fn type_body(input: Span) -> ParseResult<TypeBody> {
     context(
         "type-body",
         alt((
-            map(record_variant, move |fields| TypeBody::ImmediateRecord { id, fields }),
+            map(
+                delimited(
+                    tok(char('{')),
+                    separated_list1(tok(char(',')), record_variant_item),
+                    tok(char('}')),
+                ),
+                move |items| TypeBody::ImmediateRecord { id, fields: items },
+            ),
             map(separated_list0(tok(char('|')), variant_spec), TypeBody::Variants),
         )),
     )(input)
 }
 
-fn record_variant(input: Span) -> ParseResult<Vec<(Rc<String>, TypeIdentifier)>> {
+fn record_variant(input: Span) -> ParseResult<VariantKind> {
     context(
         "record-variant",
+        map(
             delimited(
                 pair(tok(char('{')), many0(statement_delimiter)),
-            terminated(separated_list1(toknl(char(',')), toknl(record_variant_item)), opt(toknl(char(',')))),
+                terminated(
+                    separated_list1(pair(tok(char(',')), many0(statement_delimiter)), record_variant_item),
+                    opt(tok(char(','))),
+                ),
                 pair(many0(statement_delimiter), tok(char('}'))),
             ),
+            VariantKind::Record,
+        ),
     )(input)
 }
 
@@ -356,7 +369,7 @@ fn variant_spec(input: Span) -> ParseResult<Variant> {
 
     let id = fresh_id(&input);
     let (rest, (name, kind)) = alt((
-        pair(identifier, map(record_variant, VariantKind::Record)),
+        pair(identifier, record_variant),
         pair(identifier, tuple_variant),
         map(identifier, |ident| (ident, VariantKind::UnitStruct)),
     ))(input)?;
@@ -465,8 +478,8 @@ fn operator(input: Span) -> ParseResult<BinOp> {
     context(
         "operator",
         tok(map(
-            preceded(cut(not(tag("*/"))), recognize(many1(one_of("+-*/%<>=!$&|?^`")))),
-            |sigil_span: Span| BinOp::from_sigil(sigil_span.fragment()),
+            tuple((cut(not(tag("*/"))), recognize(many1(one_of("+-*/%<>=!$&|?^`"))))),
+            |(_, sigil_span): ((), Span)| BinOp::from_sigil(sigil_span.fragment()),
         )),
     )(input)
 }
@@ -596,13 +609,10 @@ fn primary_expr_no_struct(input: Span) -> ParseResult<ExpressionKind> {
 }
 
 fn named_struct(input: Span) -> ParseResult<ExpressionKind> {
-    context(
-        "named-struct",
     map(pair(qualified_identifier, record_block), |(name, fields)| ExpressionKind::NamedStruct {
         name,
         fields,
-        }),
-    )(input)
+    })(input)
 }
 
 //TODO support anonymous structs and Elm-style update syntax for structs
@@ -614,29 +624,22 @@ fn record_block(input: Span) -> ParseResult<Vec<(Rc<String>, Expression)>> {
 }
 
 fn lambda_expr(input: Span) -> ParseResult<ExpressionKind> {
-    context(
-        "lambda-expr",
-        preceded(
-            tok(char('\\')),
     alt((
-                map(tuple((formal_params, opt(type_anno), block)), |(params, type_anno, body)| {
-                    ExpressionKind::Lambda { params, type_anno, body }
-                }),
-                map(tuple((formal_param, opt(type_anno), block)), |(param, type_anno, body)| {
-                    ExpressionKind::Lambda { params: vec![param], type_anno, body }
-                }),
-            )),
+        map(
+            preceded(tok(char('\\')), tuple((formal_params, opt(type_anno), block))),
+            |(params, type_anno, body)| ExpressionKind::Lambda { params, type_anno, body },
         ),
-    )(input)
+        map(
+            preceded(tok(char('\\')), tuple((formal_param, opt(type_anno), block))),
+            |(param, type_anno, body)| ExpressionKind::Lambda { params: vec![param], type_anno, body },
+        ),
+    ))(input)
 }
 
 fn while_expr(input: Span) -> ParseResult<ExpressionKind> {
-    context(
-        "while-expr",
     map(preceded(kw("while"), pair(opt(expression_no_struct), block)), move |(condition, body)| {
         ExpressionKind::WhileExpression { condition: condition.map(Box::new), body }
-        }),
-    )(input)
+    })(input)
 }
 
 fn if_expr(input: Span) -> ParseResult<ExpressionKind> {
@@ -685,12 +688,9 @@ fn if_expr(input: Span) -> ParseResult<ExpressionKind> {
         alt((cond_block, simple_pattern_match, simple_conditional))(input)
     }
 
-    context(
-        "if-expr",
     map(preceded(kw("if"), pair(opt(expression_no_struct), if_expr_body)), |(discriminator, body)| {
         ExpressionKind::IfExpression { discriminator: discriminator.map(Box::new), body: Box::new(body) }
-        }),
-    )(input)
+    })(input)
 }
 
 fn pattern(input: Span) -> ParseResult<Pattern> {
@@ -782,12 +782,9 @@ fn for_expr(input: Span) -> ParseResult<ExpressionKind> {
         ))(input)
     }
 
-    context(
-        "for-expr",
     map(preceded(kw("for"), pair(for_enumerators, for_body)), |(enumerators, body)| {
         ExpressionKind::ForExpression { enumerators, body }
-        }),
-    )(input)
+    })(input)
 }
 
 fn paren_expr(input: Span) -> ParseResult<ExpressionKind> {
@@ -862,23 +859,17 @@ fn bool_literal(input: Span) -> ParseResult<ExpressionKind> {
 }
 
 fn float_literal(input: Span) -> ParseResult<ExpressionKind> {
-    context(
-        "float-literal",
     tok(map(
         alt((
             recognize(tuple((digits(digit_group_dec), char('.'), opt(digits(digit_group_dec))))),
             recognize(tuple((char('.'), digits(digit_group_dec)))),
         )),
         |ds| ExpressionKind::FloatLiteral(ds.fragment().parse().unwrap()),
-        )),
-    )(input)
+    ))(input)
 }
 
 fn number_literal(input: Span) -> ParseResult<ExpressionKind> {
-    context(
-        "number-literal",
-        map(alt((tok(hex_literal), tok(bin_literal), tok(dec_literal))), ExpressionKind::NatLiteral),
-    )(input)
+    map(alt((tok(hex_literal), tok(bin_literal), tok(dec_literal))), ExpressionKind::NatLiteral)(input)
 }
 
 fn dec_literal(input: Span) -> ParseResult<u64> {

schala-lang/src/symbol_table/test.rs

@@ -254,11 +254,9 @@ fn duplicate_modules() {
 fn duplicate_struct_members() {
     let source = r#"
       type Tarak = Tarak {
-        loujet: i32
-        ,
+        loujet: i32,
+        mets: i32,
         mets: i32,
-        mets: i32
-        ,
       }
     "#;