Flatten typesets

Cargo.toml

@@ -17,6 +17,7 @@ members = [
   "ast",
   "fir",
   "flatten",
+  "dedup",
   "name_resolve",
   "include_code",
   "loop_desugar",
@@ -35,6 +36,7 @@ ast = { path = "ast" }
 ast-sanitizer = { path = "ast-sanitizer" }
 fir = { path = "fir" }
 debug-fir = { path = "debug-fir" }
+dedup = { path = "dedup" }
 flatten = { path = "flatten" }
 name_resolve = { path = "name_resolve" }
 symbol = { path = "symbol" }

ast/src/lib.rs

@@ -1,5 +1,7 @@
 //! Abstract Syntax Tree representation of jinko's source code
 
+use std::fmt;
+
 use error::{ErrKind, Error};
 use location::SpanTuple;
 use symbol::Symbol;
@@ -10,6 +12,7 @@ pub enum TypeKind {
     // probably simpler, right?
     // but then how do we handle a simple type like "int" without generics or anything -> symbol(int) and empty vec for generics so we're good
     Simple(Symbol), // FIXME: Can this be a symbol? Should it be something else? I think Symbol is fine, because the struct enclosing TypeKind has generics and location
+    Literal(Box<Ast>),
     Multi(Vec<Type>),
     FunctionLike(Vec<Type>, Option<Box<Type>>),
 }
@@ -136,6 +139,18 @@ pub enum Value {
     Str(String),
 }
 
+impl fmt::Display for Value {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Value::Integer(v) => write!(f, "{v}"),
+            Value::Float(v) => write!(f, "{v}"),
+            Value::Bool(v) => write!(f, "{v}"),
+            Value::Char(v) => write!(f, "'{v}'"),
+            Value::Str(v) => write!(f, "\"{v}\""),
+        }
+    }
+}
+
 // FIXME: How to keep location in there? How to do it ergonomically?
 // As a "Smart pointer" type? E.g by having it implement `Deref<T = AstInner>`?
 // Would that even work? If it does, it is ergonomic but boy is it not idiomatic

builtins/src/builder.rs

@@ -14,21 +14,37 @@ pub fn argument(name: &str, ty: Type) -> TypedValue {
     }
 }
 
-pub fn ty_arg(ty: BuiltinType) -> Type {
+pub fn type_symbol(symbol: &str) -> Type {
     Type {
+        kind: TypeKind::Simple(Symbol::from(symbol)),
         location: SpanTuple::builtin(),
         generics: vec![],
+    }
+}
+
+pub fn builtin_type_symbol(ty: BuiltinType) -> Type {
+    Type {
         kind: TypeKind::Simple(Symbol::from(ty.name())),
+        location: SpanTuple::builtin(),
+        generics: vec![],
     }
 }
 
-pub fn ty(ty: BuiltinType) -> Ast {
+fn union_content(types: Vec<Type>) -> TypeContent {
+    TypeContent::Alias(Type {
+        kind: TypeKind::Multi(types),
+        location: SpanTuple::builtin(),
+        generics: vec![],
+    })
+}
+
+pub fn union_type(ty: BuiltinType, variants: Vec<Type>) -> Ast {
     Ast {
         location: SpanTuple::builtin(),
         node: Node::Type {
             name: Symbol::from(ty.name()),
+            fields: union_content(variants),
             generics: vec![],
-            fields: TypeContent::None,
             with: None,
         },
     }