Implement return generation

examples/hello_world.sb

@@ -1,5 +1,4 @@
 fn main() {
-    let x = "Hello World";
     return;
 }
 

examples_out/out.js

@@ -1,3 +1,6 @@
-function main() {}
-function fib() {}
+function main() {
+return;
+}
+function fib() {
+}
 main()

src/generator/js.rs

@@ -23,9 +23,43 @@ fn generate_function(func: Function) -> String {
         .into_iter()
         .map(|arg: Variable| format!("{},", arg.name))
         .collect();
-    let mut raw = format!("function {N}({A}) ", N = func.name, A = arguments);
+    let mut raw = format!("function {N}({A})", N = func.name, A = arguments);
 
-    raw += "{}\n";
+    raw += " {\n";
+
+    for statement in func.statements {
+        raw += &generate_statement(statement);
+    }
+
+    raw += "}\n";
 
     raw
 }
+
+fn generate_statement(statement: Statement) -> String {
+    match statement {
+        Statement::Return(ret) => generate_return(ret),
+        Statement::Declare(_, _) => todo!(),
+        Statement::Exp(val) => generate_expression(val),
+        Statement::Compound(_) => todo!(),
+        Statement::If(_, _, _) => todo!(),
+        Statement::While(_, _) => todo!(),
+    }
+}
+
+fn generate_expression(expr: Expression) -> String {
+    match expr {
+        Expression::Int(val) => val.to_string(),
+        Expression::Variable(val) | Expression::Str(val) => val,
+        Expression::Char(_) => todo!(),
+        Expression::FunctionCall(_, _) => todo!(),
+        Expression::Assign(_, _) => todo!(),
+    }
+}
+
+fn generate_return(ret: Option<Expression>) -> String {
+    match ret {
+        Some(expr) => format!("return {}\n", generate_expression(expr)),
+        None => "return;\n".to_string(),
+    }
+}

src/parser/node_type.rs

@@ -33,8 +33,5 @@ pub enum Expression {
     Char(u8),
     FunctionCall(String, Vec<Expression>),
     Variable(String),
-    VariableRef(String),
     Assign(String, Box<Expression>),
-    AssignPostfix(String, Box<Expression>),
-    Ternary(Box<Expression>, Box<Expression>, Box<Expression>),
 }