crates/codegen/src/ts.rs

@@ -31,10 +31,9 @@ impl Codegen {
         macro_rules! semicolon { () => { if should_gen_semicolon { ";" } else { "" } }; }
 
         match ir {
-            IRKind::Define { public, name, type_hint, value, mutable } => {
+            IRKind::Define { name, type_hint, value, mutable } => {
                 format!(
-                    "{} {} v_{}: {} = {}{}\n",
+                    "{} v_{}: {} = {}{}\n",
-                    if *public { "export" } else { "" },
                     if *mutable { "let" } else { "const" },
                     name, 
                     type_hint,
@@ -68,15 +67,14 @@ impl Codegen {
                 }
             },
 
-            IRKind::Fun { public, name, return_type_hint, args, body } => {
+            IRKind::Fun { name, return_type_hint, args, body } => {
                 let args = args
                     .iter()
                     .map(|arg| format!("v_{}: {}", arg.0, arg.1))
                     .collect::<Vec<_>>().
                     join(", ");
                 format!(
-                    "{} const f_{} = ({}): {} => {};\n",
+                    "const f_{} = ({}): {} => {};\n",
-                    if *public { "export" } else { "" },
                     name,
                     args,
                     return_type_hint,

crates/diagnostic/src/lib.rs

@@ -47,6 +47,7 @@ impl Diagnostics {
             _ => None,
         });
 
+        // TODO: Lowering error
         lex_error.into_iter()
         .map(|e| e.map(|e| e.to_string()))
         .chain(parse_error.into_iter().map(|e| e.map(|tok| tok.to_string())))

crates/hir/src/lib.rs

@@ -14,21 +14,8 @@ pub enum Value { Int(i64), Boolean(bool), String(String), Ident(String) }
 
 #[derive(Debug, Clone)]
 pub enum IRKind {
-    Define {
+    Define { name: String, type_hint: String, value: Box<Self>, mutable: bool },
-        public: bool,
+    Fun { name: String, return_type_hint: String, args: Vec<(String, String)>, body: Box<Self> },
-        name: String,
-        type_hint: String,
-        value: Box<Self>,
-        mutable: bool
-    },
-    Fun {
-        public: bool,
-        name: String,
-        return_type_hint: String,
-        args: Vec<(String, String)>,
-        body: Box<Self>
-    },
-
     Call { name: String, args: Vec<Self> },
     Intrinsic { name: String, args: Vec<Self> },
     Do { body: Vec<Self> },
@@ -53,19 +40,21 @@ pub struct LoweringError {
     pub note: Option<String>,
 }
 
+impl IR {
+    pub fn new(kind: IRKind, span: Range<usize>) -> Self {
+        Self { kind, span }
+    }
+}
+
 pub fn ast_to_ir(ast: Vec<(Expr, Range<usize>)>) -> (Vec<IR>, Vec<LoweringError>) {
     let mut irs = Vec::new();
     let mut errors = Vec::new();
     for expr in ast {
         let ir_kind = expr_to_ir(&expr.0);
-        match ir_kind {
+        if let Some(err) = ir_kind.1 {
-            (Some(ir), None) => {
-                irs.push(IR { kind: ir, span: expr.1 });
-            },
-            (None, Some(err)) => {
             errors.push(err);
-            },
+        } else {
-            _ => unreachable!(),
+            irs.push(IR::new(ir_kind.0.unwrap(), expr.1));
         }
     }
     (irs, errors)
@@ -199,13 +188,12 @@ pub fn expr_to_ir(expr: &Expr) -> (Option<IRKind>, Option<LoweringError>) {
             };
         },
 
-        Expr::Let { public, name, type_hint, value, mutable } => {
+        Expr::Let { name, type_hint, value, mutable } => {
             let value = expr_to_ir(&value.0);
             if_err_return!(value.1);
 
             let value = value.0.unwrap();
             let ir_kind = IRKind::Define {
-                public: *public,
                 name: name.clone(),
                 type_hint: gen_type_hint(type_hint),
                 value: Box::new(value),
@@ -247,7 +235,7 @@ pub fn expr_to_ir(expr: &Expr) -> (Option<IRKind>, Option<LoweringError>) {
             return (Some(ir_kind), None);
         },
 
-        Expr::Fun { public, name, type_hint, args, body } => {
+        Expr::Fun { name, type_hint, args, body } => {
             // Iterate each argument and give it a type hint
             let args = args.0.iter().map(|arg| (arg.0.0.clone(), gen_type_hint(&arg.1.0))).collect::<Vec<_>>();
 
@@ -255,13 +243,7 @@ pub fn expr_to_ir(expr: &Expr) -> (Option<IRKind>, Option<LoweringError>) {
             if_err_return!(body.1);
 
             let body = body.0.unwrap();
-            let ir_kind = IRKind::Fun {
+            let ir_kind = IRKind::Fun { name: name.clone(), return_type_hint: gen_type_hint(type_hint), args, body: Box::new(body) };
-                public: *public,
-                name: name.clone(),
-                return_type_hint: gen_type_hint(type_hint),
-                args,
-                body: Box::new(body)
-            };
             return (Some(ir_kind), None);
         },
 

crates/lexer/src/lib.rs

@@ -8,7 +8,6 @@ pub enum Token {
     KwIf, KwThen, KwElse,
     KwCase, KwOf,
     KwReturn,
-    KwPub,
 
     // Literals
     Int(i64), Boolean(bool),
@@ -43,7 +42,6 @@ impl std::fmt::Display for Token {
             Token::KwCase => write!(f, "case"),
             Token::KwOf => write!(f, "of"),
             Token::KwReturn => write!(f, "return"),
-            Token::KwPub => write!(f, "pub"),
 
             Token::Int(i) => write!(f, "{}", i),
             Token::Boolean(b) => write!(f, "{}", b),
@@ -132,7 +130,6 @@ pub fn lexer() -> impl Parser<char, Vec<(Token, Span)>, Error = Simple<char>> {
         "case" => Token::KwCase,
         "of" => Token::KwOf,
         "return" => Token::KwReturn,
-        "pub" => Token::KwPub,
         _ => Token::Identifier(s),
     });
 

crates/parser/src/lib.rs

@@ -15,14 +15,12 @@ pub enum Expr {
     Intrinsic { name: Box<Spanned<Self>>, args: Spanned<Vec<Spanned<Self>>> },
 
     Let {
-        public: bool,
         name: String,
         type_hint: String,
         value: Box<Spanned<Self>>,
         mutable: bool,
     },
     Fun {
-        public: bool,
         name: String,
         type_hint: String,
         args: Spanned<Vec<(Spanned<String>, Spanned<String>)>>,
@@ -200,18 +198,16 @@ fn expr_parser() -> impl Parser<Token, Vec<Spanned<Expr>>, Error = Simple<Token>
                 )
             });
 
-        let let_ = just(Token::KwPub).or_not()
+        let let_ = just(Token::KwLet)
-            .then_ignore(just(Token::KwLet))
+            .ignore_then(just(Token::KwMut).or_not())
-            .then(just(Token::KwMut).or_not())
             .then(identifier)
             .then_ignore(just(Token::Colon))
             .then(identifier)
             .then_ignore(just(Token::Assign))
             .then(expr.clone())
-            .map(|((((public, mutable), name), type_hint), value)| {
+            .map(|(((mutable, name), type_hint), value)| {
                 (
                     Expr::Let {
-                        public: public.is_some(),
                         name: name.0.clone(),
                         type_hint: type_hint.0,
                         value: Box::new(value.clone()),
@@ -221,9 +217,8 @@ fn expr_parser() -> impl Parser<Token, Vec<Spanned<Expr>>, Error = Simple<Token>
                 )
             });
 
-        let fun = just(Token::KwPub).or_not()
+        let fun = just(Token::KwFun)
-            .then_ignore(just(Token::KwFun))
+            .ignore_then(identifier)
-            .then(identifier)
             .then(
                 identifier
                     .then_ignore(just(Token::Colon))
@@ -238,10 +233,9 @@ fn expr_parser() -> impl Parser<Token, Vec<Spanned<Expr>>, Error = Simple<Token>
             .then(identifier)
             .then_ignore(just(Token::Assign))
             .then(expr.clone())
-            .map(|((((public, name), args), type_hint), body)| {
+            .map(|(((name, args), type_hint), body)| {
                 (
                     Expr::Fun {
-                        public: public.is_some(),
                         name: name.0.clone(),
                         type_hint: type_hint.0,
                         args: (args, name.1.clone()),

example/export.hz

@@ -1,4 +0,0 @@
-pub fun print_something: void = @emit("console.log('something')");
-
-fun main: void = do
-end;