Merge branch 'master' of https://github.com/jfecher/ante

README.md

@@ -97,7 +97,7 @@ The project itself provides build instructions for the [Nix package manager](htt
 Those can be used for the most recent version of the compiler, or for working on it.
 
 To enter the development environment, run either `nix-shell` or `nix develop` depending on whether you are using nix
-with [flakes](https://nixos.wiki/wiki/Flakes) and [nix command](https://nixos.wiki/wiki/Nix_command) enabled or not.
+with [flakes](https://wiki.nixos.org/wiki/Flakes) and [nix command](https://wiki.nixos.org/wiki/Nix_command) enabled or not.
 Then you can build and run the project with `cargo` as described at the top of this section.
 
 Beyond that, the project will also build with `nix-build` / `nix build`, meaning you can install it on your system using

ante-ls/src/main.rs

@@ -136,7 +136,7 @@ impl LanguageServer for Backend {
                 let name = v.kind.name();
 
                 let value =
-                    typeprinter::show_type_and_traits(&name, typ, &info.required_traits, &info.trait_info, &cache);
+                    typeprinter::show_type_and_traits(&name, typ, &info.required_traits, &info.trait_info, &cache, false);
 
                 let location = v.locate();
                 let range =

examples/codegen/mutability.an

@@ -6,7 +6,7 @@ print num
 mutate num
 print num
 
-mutate (n: &mut I32) =
+mutate (n: !I32) =
     x = double @n
     n := x
 

examples/codegen/pass_by_ref.an

@@ -12,7 +12,7 @@ foo (x: S) (y: S) =
     printne "x before: "
     print x
     z = mut y
-    z.&message := "modifying y"
+    z.!message := "modifying y"
     printne "x after:  "
     print x
 

examples/codegen/string_builder.an

@@ -1,6 +1,6 @@
 import StringBuilder
 
-sb: &mut StringBuilder = mut empty ()
+sb: !StringBuilder = mut empty ()
 reserve sb 10
 append sb "你好，"
 append sb " World!"

examples/regressions/129_int_defaulting_generalization.an

@@ -12,9 +12,9 @@ second b + 2i64
 
 // args: --check --show-types
 // expected stdout:
-// a : (U64, I64)
-// b : (U64, I64)
-// c : (U64, I64)
+// a : U64, I64
+// b : U64, I64
+// c : U64, I64
 
 // Expected results with the function block uncommented:
 // f : (forall a. (Unit -> (U64, I64) can a))

examples/typechecking/bind.an

@@ -12,7 +12,7 @@ add_one x =
 
 // args: --check --show-types
 // expected stdout:
-// add_one : (forall a. ((Maybe I32) -> (Maybe I32) can a))
-// bind : (forall a b c d. ((Maybe c) - (c => (Maybe b) can d) -> (Maybe b) can d))
-// ret : (forall a b. (a -> (Maybe a) can b))
-// x : (Maybe I32)
+// add_one : forall a. (Maybe I32 -> Maybe I32 can a)
+// bind : forall a b c d. (Maybe c - (c => Maybe b can d) -> Maybe b can d)
+// ret : forall a b. (a -> Maybe a can b)
+// x : Maybe I32

examples/typechecking/completeness_checking.an

@@ -46,5 +46,5 @@ match (1, 2, 3, 4)
 // completeness_checking.an:20:1	error: Missing case (false, false)
 // match (true, true)
 // 
-// completeness_checking.an:25:4	error: This pattern of type ((Int a), (Int b)) does not match the type ((Int a), ((Int b), ((Int c), (Int d)))) that is being matched on
+// completeness_checking.an:25:4	error: This pattern of type Int a, Int b does not match the type Int a, Int b, Int c, Int d that is being matched on
 // | (1, 2) -> 1

examples/typechecking/effects.an

@@ -23,10 +23,10 @@ does_use x =
 
 // args: --check --show-types
 // expected stdout:
-// does_use : (forall a b. (a -> Unit can (Use a, b)))
+// does_use : forall a b. (a -> Unit can (Use a, b))
 //   given Add a
-// get : (forall a b. (Unit -> a can (Use a, b)))
-// handle_basic : (forall a. (Unit -> Unit can (Use String, a)))
-// log : (forall a. (String -> Unit can (Log, a)))
-// set : (forall a b. (a -> Unit can (Use a, b)))
-// use_resume : (forall a. (Unit -> Unit can a))
+// get : forall a b. (Unit -> a can (Use a, b))
+// handle_basic : forall a. (Unit -> Unit can (Use String, a))
+// log : forall a. (String -> Unit can (Log, a))
+// set : forall a b. (a -> Unit can (Use a, b))
+// use_resume : forall a. (Unit -> Unit can a)

examples/typechecking/extern.an

@@ -12,7 +12,7 @@ exit2 0
 
 // args: --check --show-types
 // expected stdout:
-// add : (forall a. (I32 - I32 -> I32 can a))
-// exit2 : (forall a b. (I32 -> a can b))
-// foo : (forall a b c. (a -> b can c))
-// puts2 : (forall a. (String -> Unit can a))
+// add : forall a. (I32 - I32 -> I32 can a)
+// exit2 : forall a b. (I32 -> a can b)
+// foo : forall a b c. (a -> b can c)
+// puts2 : forall a. (String -> Unit can a)

examples/typechecking/functor_and_monad.an

@@ -23,9 +23,9 @@ impl Monad Maybe with
 
 // args: --check --show-types
 // expected stdout:
-// bind : (forall a b c d e. ((a b) - (b -> (a c) can d) -> (a c) can e))
+// bind : forall a b c d e. (a b - (b -> a c can d) -> a c can e)
 //   given Monad a
-// map : (forall a b c d e. ((a b) - (b -> c can d) -> (a c) can e))
+// map : forall a b c d e. (a b - (b -> c can d) -> a c can e)
 //   given Functor a
-// wrap : (forall a b c. (b -> (a b) can c))
+// wrap : forall a b c. (b -> a b can c)
 //   given Monad a

examples/typechecking/generalization.an

@@ -6,4 +6,4 @@ foo x =
 
 // args: --check --show-types
 // expected stdout:
-// foo : (forall a b c d. (a -> (b => a can c) can d))
+// foo : forall a b c d. (a -> b => a can c can d)

examples/typechecking/impl.an

@@ -23,5 +23,5 @@ c = foo "one" "two"
 // a : I32
 // b : F64
 // c : String
-// foo : (forall a b. (a - a -> a can b))
+// foo : forall a b. (a - a -> a can b)
 //   given Foo a

examples/typechecking/instantiation.an

@@ -14,8 +14,8 @@ id x = x
 
 // args: --check --show-types
 // expected stdout:
-// add : (forall a b c d e f g h i. ((a - c => e can g) - (a - b => c can g) -> (a => (b => e can g) can h) can i))
-// id : (forall a b. (a -> a can b))
-// one : (forall a b c d. ((a => b can d) - a -> b can d))
-// two1 : (forall a b c. ((a => a can c) - a -> a can c))
-// two2 : ((a => a can c) => (a => a can c) can d)
+// add : forall a b c d e f g h i. ((a - c => e can g) - (a - b => c can g) -> a => b => e can g can h can i)
+// id : forall a b. (a -> a can b)
+// one : forall a b c d. ((a => b can d) - a -> b can d)
+// two1 : forall a b c. ((b => b can c) - b -> b can c)
+// two2 : (a => a can c) => a => a can c can d

examples/typechecking/member_access.an

@@ -22,11 +22,11 @@ foo_and_bar foo bar
 // 
 
 // expected stdout:
-// Bar : (forall a. (Char -> Bar can a))
-// Foo : (forall a. (F64 -> Foo can a))
-// FooBar : (forall a. (I32 - String -> FooBar can a))
+// Bar : forall a. (Char -> Bar can a)
+// Foo : forall a. (F64 -> Foo can a)
+// FooBar : forall a. (I32 - String -> FooBar can a)
 // bar : Bar
 // foo : Foo
-// foo_and_bar : (forall a b c d. ({ foo: a, ..b } - { bar: String, ..c } -> String can d))
+// foo_and_bar : forall a b c d. ({ foo: a, ..b } - { bar: String, ..c } -> String can d)
 // foobar : FooBar
-// stringify : (forall a. (String -> String can a))
+// stringify : forall a. (String -> String can a)

examples/typechecking/mutual_recursion.an

@@ -16,7 +16,7 @@ is_even 4
 // TODO: is_odd here uses `forall a c.` instead of `forall a b.`
 
 // expected stdout:
-// is_even : (forall a b. ((Int a) -> Bool can b))
-//   given Eq (Int a), Print (Int a), Sub (Int a)
-// is_odd : (forall a c. ((Int a) -> Bool can c))
-//   given Eq (Int a), Print (Int a), Sub (Int a)
+// is_even : forall a b. (Int a -> Bool can b)
+//   given Eq Int a, Print Int a, Sub Int a
+// is_odd : forall a c. (Int a -> Bool can c)
+//   given Eq Int a, Print Int a, Sub Int a

examples/typechecking/named_constructor.an

@@ -8,6 +8,6 @@ foo = hello_foo 42
 
 // args: --check --show-types
 // expected stdout:
-// Foo : (forall a b c. (a - b -> (Foo a b) can c))
-// foo : (Foo String (Int a))
-// hello_foo : (forall a b. (a -> (Foo String a) can b))
+// Foo : forall a b c. (a - b -> Foo a b can c)
+// foo : Foo String (Int a)
+// hello_foo : forall a b. (a -> Foo String a can b)

examples/typechecking/repeated_traits.an

@@ -5,5 +5,5 @@ foo a =
 // Make sure output is not "... given Print a, Print a"
 // args: --check --show-types
 // expected stdout:
-// foo : (forall a b. (a -> Unit can b))
+// foo : forall a b. (a -> Unit can b)
 //   given Print a

examples/typechecking/trait_fundep_result.an

@@ -9,6 +9,6 @@ str = foo 0i32
 
 // args: --check --show-types
 // expected stdout:
-// foo : (forall a b c. (a -> b can c))
+// foo : forall a b c. (a -> b can c)
 //   given Foo a b
 // str : String

examples/typechecking/trait_generalization.an

@@ -1,4 +1,4 @@
 a = "test".c_string
 
 // args: --check --show-types
-// expected stdout: a : (Ptr Char)
+// expected stdout: a : Ptr Char

examples/typechecking/trait_propagation.an

@@ -11,10 +11,10 @@ foo () = baz bar
 // 
 // args: --check --show-types
 // expected stdout:
-// bar : (forall a. a)
-// baz : (forall a b. (a -> Unit can b))
+// bar : forall a. a
+// baz : forall a b. (a -> Unit can b)
 //   given Baz a
-// foo : (forall a. (Unit -> Unit can a))
+// foo : forall a. (Unit -> Unit can a)
 
 // expected stderr:
 // trait_propagation.an:6:10	error: No impl found for Baz a

examples/typechecking/type_annotations.an

@@ -22,8 +22,8 @@ puts2
 // 
 
 // expected stdout:
-// bar : (forall a. (I32 - I32 -> I32 can a))
-// baz : (forall a b. (Usz -> (Ptr a) can b))
-// exit2 : (forall a b. (I32 -> a can b))
-// foo : (forall a. (I32 - String -> Char can a))
-// puts2 : (forall a. ((Ptr Char) -> I32 can a))
+// bar : forall a. (I32 - I32 -> I32 can a)
+// baz : forall a b. (Usz -> Ptr a can b)
+// exit2 : forall a b. (I32 -> a can b)
+// foo : forall a. (I32 - String -> Char can a)
+// puts2 : forall a. (Ptr Char -> I32 can a)

src/error/mod.rs

@@ -83,6 +83,7 @@ pub enum DiagnosticKind {
     NoMatchingImpls(/*constraint*/ String),
     UnreachablePattern,
     MissingCase(/*case*/ String),
+    UnhandledEffectsInMain(/*effects*/ String),
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
@@ -152,7 +153,7 @@ impl Display for DiagnosticKind {
             DiagnosticKind::PreviouslyDefinedHere(item) => {
                 write!(f, "{} was previously defined here", item)
             },
-            DiagnosticKind::IncorrectConstructorArgCount(item, expected, actual) => {
+            DiagnosticKind::IncorrectConstructorArgCount(item, actual, expected) => {
                 let plural_s = if *expected == 1 { "" } else { "s" };
                 let is_are = if *actual == 1 { "is" } else { "are" };
                 write!(
@@ -161,7 +162,7 @@ impl Display for DiagnosticKind {
                     item, expected, plural_s, actual, is_are
                 )
             },
-            DiagnosticKind::IncorrectImplTraitArgCount(trait_name, expected, actual) => {
+            DiagnosticKind::IncorrectImplTraitArgCount(trait_name, actual, expected) => {
                 let plural_s = if *expected == 1 { "" } else { "s" };
                 write!(f, "impl has {} type argument{} but {} requires {}", expected, plural_s, trait_name, actual)
             },
@@ -240,80 +241,80 @@ impl Display for DiagnosticKind {
                     "Invalid syntax in irrefutable pattern, expected a name, type annotation, or type constructor"
                 )
             },
-            DiagnosticKind::FunctionParameterCountMismatch(typ, expected, actual) => {
+            DiagnosticKind::FunctionParameterCountMismatch(typ, actual, expected) => {
                 let plural_s = if *expected == 1 { "" } else { "s" };
                 let was_were = if *actual == 1 { "was" } else { "were" };
                 write!(f, "Function of type {typ} declared to take {expected} parameter{plural_s}, but {actual} {was_were} supplied")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::ExpectedUnitTypeFromPattern, _expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::ExpectedUnitTypeFromPattern, actual, _expected) => {
                 write!(f, "Expected a unit type from this pattern, but the corresponding value has the type {}", actual)
             },
-            DiagnosticKind::TypeError(TypeErrorKind::ExpectedPairTypeFromPattern, _, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::ExpectedPairTypeFromPattern, actual, _expected) => {
                 write!(f, "Expected a pair type from this pattern, but found {actual}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::VariableDoesNotMatchDeclaredType, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::VariableDoesNotMatchDeclaredType, actual, expected) => {
                 write!(f, "Variable type {actual} does not match its declared type of {expected}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::PatternTypeDoesNotMatchAnnotatedType, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::PatternTypeDoesNotMatchAnnotatedType, actual, expected) => {
                 write!(f, "Pattern type {actual} does not match the annotated type {expected}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::PatternTypeDoesNotMatchDefinitionType, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::PatternTypeDoesNotMatchDefinitionType, actual, expected) => {
                 write!(f, "Pattern type {actual} does not match the definition's type {expected}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::FunctionBodyDoesNotMatchReturnType, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::FunctionBodyDoesNotMatchReturnType, actual, expected) => {
                 write!(f, "Function body type {actual} does not match declared return type of {expected}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::CalledValueIsNotAFunction, _, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::CalledValueIsNotAFunction, actual, _expected) => {
                 write!(f, "Value being called is not a function, it is a {actual}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::ArgumentTypeMismatch, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::ArgumentTypeMismatch, actual, expected) => {
                 write!(f, "Expected argument of type {expected}, but found {actual}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::NonBoolInCondition, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::NonBoolInCondition, actual, expected) => {
                 write!(f, "{actual} should be a {expected} to be used in an if condition")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::IfBranchMismatch, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::IfBranchMismatch, actual, expected) => {
                 write!(
                     f,
                     "Expected 'then' and 'else' branch types to match, but found {expected} and {actual} respectively"
                 )
             },
-            DiagnosticKind::TypeError(TypeErrorKind::MatchPatternTypeDiffers, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::MatchPatternTypeDiffers, actual, expected) => {
                 write!(f, "This pattern of type {actual} does not match the type {expected} that is being matched on")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::MatchReturnTypeDiffers, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::MatchReturnTypeDiffers, actual, expected) => {
                 write!(
                     f,
                     "This branch's return type {actual} does not match the previous branches which return {expected}"
                 )
             },
-            DiagnosticKind::TypeError(TypeErrorKind::DoesNotMatchAnnotatedType, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::DoesNotMatchAnnotatedType, actual, expected) => {
                 write!(f, "Expression of type {actual} does not match its annotated type {expected}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::ExpectedStructReference, _, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::ExpectedStructReference, actual, _expected) => {
                 write!(f, "Expected a struct reference but found {actual} instead")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::NoFieldOfType(field_name), expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::NoFieldOfType(field_name), actual, expected) => {
                 write!(f, "{actual} has no field '{field_name}' of type {expected}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::AssignToNonMutRef, expected, actual) => {
-                write!(f, "Expression of type {actual} must be a `{expected}` type to be assigned to")
+            DiagnosticKind::TypeError(TypeErrorKind::AssignToNonMutRef, actual, expected) => {
+                write!(f, "Expression of type {actual} must be a mutable reference type ({expected}) to be assigned to")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::AssignToWrongType, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::AssignToWrongType, actual, expected) => {
                 write!(f, "Cannot assign expression of type {actual} to a Ref of type {expected}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::HandleBranchMismatch, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::HandleBranchMismatch, actual, expected) => {
                 write!(f, "The type of this branch ({actual}) should match the type of the expression being handled: {expected}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::PatternReturnTypeMismatch, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::PatternReturnTypeMismatch, actual, expected) => {
                 write!(f, "Expected type {expected} does not match the pattern's return type {actual}")
             },
-            DiagnosticKind::TypeError(TypeErrorKind::NeverShown, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::NeverShown, actual, expected) => {
                 unreachable!("This type error should never be shown. Expected {}, Actual {}", expected, actual)
             },
-            DiagnosticKind::TypeError(TypeErrorKind::MonomorphizationError, expected, actual) => {
+            DiagnosticKind::TypeError(TypeErrorKind::MonomorphizationError, actual, expected) => {
                 unreachable!(
-                    "Unification error during monomorphisation: Could not unify definition {} with instantiation {}",
+                    "Unification error during monomorphization: Could not unify definition {} with instantiation {}",
                     expected, actual
                 )
             },
@@ -335,6 +336,9 @@ impl Display for DiagnosticKind {
             DiagnosticKind::MissingCase(case) => {
                 write!(f, "Missing case {case}")
             },
+            DiagnosticKind::UnhandledEffectsInMain(effects) => {
+                write!(f, "Unhandled effects at top-level: {effects}")
+            },
         }
     }
 }
@@ -381,6 +385,7 @@ impl DiagnosticKind {
             | InternalError(_)
             | NotAStruct(_)
             | MissingFields(_)
+            | UnhandledEffectsInMain(_)
             | NotAStructField(_) => Error,
         }
     }