Remove unnecessary semicolons from the grammar

crates/ditto-checker/src/module/foreign_value_declarations/mod.rs

@@ -18,10 +18,12 @@ pub fn kindcheck_foreign_value_declarations(
         foreign_keyword,
         name,
         type_annotation,
-        semicolon,
     } in foreign_value_declarations
     {
-        let span = foreign_keyword.0.get_span().merge(&semicolon.0.get_span());
+        let span = foreign_keyword
+            .0
+            .get_span()
+            .merge(&type_annotation.get_span());
         let mut state = kindchecker::State::default();
         let foreign_type = typechecker::pre_ast::check_type_annotation(
             env_types,

crates/ditto-checker/src/module/type_declarations/tests/macros.rs

@@ -73,7 +73,7 @@ macro_rules! assert_type_declaration_error {
 
 macro_rules! parse_type_declaration {
     ($decl:expr) => {{
-        let parse_result = ditto_cst::TypeDeclaration::parse(&format!("{};", $decl));
+        let parse_result = ditto_cst::TypeDeclaration::parse($decl);
         assert!(
             matches!(parse_result, Ok(_)),
             "{:#?}",
@@ -85,7 +85,7 @@ macro_rules! parse_type_declaration {
 
 macro_rules! parse_type_alias_declaration {
     ($decl:expr) => {{
-        let parse_result = ditto_cst::TypeAliasDeclaration::parse(&format!("{};", $decl));
+        let parse_result = ditto_cst::TypeAliasDeclaration::parse($decl);
         assert!(
             matches!(parse_result, Ok(_)),
             "{:#?}",

crates/ditto-checker/src/module/value_declarations/tests/macros.rs

@@ -44,7 +44,7 @@ macro_rules! assert_value_declaration_error {
 
 macro_rules! parse_value_declaration {
     ($decl:expr) => {{
-        let parse_result = ditto_cst::ValueDeclaration::parse(&format!("{};", $decl));
+        let parse_result = ditto_cst::ValueDeclaration::parse($decl);
         assert!(
             matches!(parse_result, Ok(_)),
             "{:#?}",

crates/ditto-checker/src/typechecker/coverage/tests.rs

@@ -4,41 +4,41 @@ use macros::assert_not_covered;
 fn it_errors_for_non_exhaustive_patterns() {
     assert_not_covered!(
         r#"
-        module Test exports (..);
-        type Foo = A | B;
-        test = fn (x: Foo) -> match x with | A -> 5 end;
+        module Test exports (..)
+        type Foo = A | B
+        test = fn (x: Foo) -> match x with | A -> 5 end
         "#,
         &["B"]
     );
     assert_not_covered!(
         r#"
-        module Test exports (..);
-        type Maybe(a) = Just(a) | None;
-        test = fn (x: Maybe(a)) -> match x with | Just(a) -> a end;
+        module Test exports (..)
+        type Maybe(a) = Just(a) | None
+        test = fn (x: Maybe(a)) -> match x with | Just(a) -> a end
         "#,
         &["None"]
     );
     assert_not_covered!(
         r#"
-        module Test exports (..);
-        type Maybe(a) = Just(a) | None;
-        test = fn (x: Maybe(Int)) -> match x with | None -> 2 end;
+        module Test exports (..)
+        type Maybe(a) = Just(a) | None
+        test = fn (x: Maybe(Int)) -> match x with | None -> 2 end
         "#,
         &["Just(_)"]
     );
     assert_not_covered!(
         r#"
-        module Test exports (..);
-        type Maybe(a) = Just(a) | None;
-        test = fn (x) -> match x with | Just(None) -> 2 end;
+        module Test exports (..)
+        type Maybe(a) = Just(a) | None
+        test = fn (x) -> match x with | Just(None) -> 2 end
         "#,
         &["None", "Just(Just(_))"]
     );
     assert_not_covered!(
         r#"
-        module Test exports (..);
-        type Maybe(a) = Just(a) | None;
-        test = fn (x) -> match x with | Just(Just(Just(None))) -> 2 end;
+        module Test exports (..)
+        type Maybe(a) = Just(a) | None
+        test = fn (x) -> match x with | Just(Just(Just(None))) -> 2 end
         "#,
         &[
             "None",
@@ -49,28 +49,28 @@ fn it_errors_for_non_exhaustive_patterns() {
     );
     assert_not_covered!(
         r#"
-        module Test exports (..);
-        type Maybe(a) = Just(a) | None;
-        type Result(a, e) = Ok(a) | Err(e);
-        test = fn (x: Result(Maybe(Maybe(Int)), String)) -> match x with | Err(str) -> str end;
+        module Test exports (..)
+        type Maybe(a) = Just(a) | None
+        type Result(a, e) = Ok(a) | Err(e)
+        test = fn (x: Result(Maybe(Maybe(Int)), String)) -> match x with | Err(str) -> str end
         "#,
         &["Ok(_)"]
     );
     assert_not_covered!(
         r#"
-        module Test exports (..);
-        type Maybe(a) = Just(a) | None;
-        type Result(a, e) = Ok(a) | Err(e);
-        test = fn (x: Result(Maybe(Maybe(Int)), String)) -> match x with | Ok(Just(None)) -> "noice" end;
+        module Test exports (..)
+        type Maybe(a) = Just(a) | None
+        type Result(a, e) = Ok(a) | Err(e)
+        test = fn (x: Result(Maybe(Maybe(Int)), String)) -> match x with | Ok(Just(None)) -> "noice" end
         "#,
         &["Err(_)", "Ok(None)", "Ok(Just(Just(_)))"]
     );
     assert_not_covered!(
         r#"
-        module Test exports (..);
-        type Maybe(a) = Just(a) | None;
-        type A = A(Maybe(Maybe(Int)));
-        test = fn (a: A) -> match a with | A(Just(Just(n))) -> "yeh?" end;
+        module Test exports (..)
+        type Maybe(a) = Just(a) | None
+        type A = A(Maybe(Maybe(Int)))
+        test = fn (a: A) -> match a with | A(Just(Just(n))) -> "yeh?" end
         "#,
         &["A(None)", "A(Just(None))"]
     );
@@ -82,14 +82,14 @@ fn it_errors_for_non_exhaustive_patterns() {
     // Would be nice if we could qualify only when needed?
     assert_not_covered!(
         r#"
-        module Test exports (..);
-        import (test-stuff) Data.Stuff as A;
-        import Data.Stuff as B;
+        module Test exports (..)
+        import (test-stuff) Data.Stuff as A
+        import Data.Stuff as B
 
         option_of_option = fn (oo) ->
           match oo with
           | A.Some(B.None) -> unit
-          end;
+          end
         "#,
         &["None", "Some(Some(_))"],
         &mk_everything()
@@ -102,9 +102,9 @@ fn mk_everything() -> crate::Everything {
             module Data.Stuff exports (
                 Five(..),
                 Option(..),
-            );
-            type Option(a) = Some(a) | None;
-            type Five = Five;
+            )
+            type Option(a) = Some(a) | None
+            type Five = Five
         "#,
     );
 

crates/ditto-checker/src/typechecker/tests/let.rs

@@ -3,14 +3,14 @@ use crate::Warning::*;
 
 #[test]
 fn it_typechecks_as_expected() {
-    assert_type!("let five : Int = 5; in five", "Int");
+    assert_type!("let five : Int = 5 in five", "Int");
     assert_type!(
-        "let five : Int = 5; fives = [five, five, five]; in fives",
+        "let five : Int = 5 fives = [five, five, five] in fives",
         "Array(Int)"
     );
 }
 
 #[test]
 fn it_warns_as_expected() {
-    assert_type!("let five = 5; in unit", "Unit", [UnusedLetBinder { .. }]);
+    assert_type!("let five = 5 in unit", "Unit", [UnusedLetBinder { .. }]);
 }

crates/ditto-checker/tests/cmd/always_partial_application/test.stdin

@@ -1,7 +1,7 @@
-module Test exports (..);
+module Test exports (..)
 
-always = fn (a) -> fn (_b) -> a;
-five: Int = always(5)(true);
+always = fn (a) -> fn (_b) -> a
+five: Int = always(5)(true)
 
-always_five: (a) -> Int = always(5);
-another_five: Int = always_five(unit);
+always_five: (a) -> Int = always(5)
+another_five: Int = always_five(unit)