C like var declerations

codegen/src/lib.rs

@@ -142,7 +142,12 @@ impl GoCodegen {
                 self.indent -= 1;
                 self.add_indentedln("}\n");
             }
-            Statement::VarDecl { kind, name, init } => {
+            Statement::VarDecl {
+                kind,
+                name,
+                init,
+                type_,
+            } => {
                 let go_kind = match kind {
                     VarKind::Let | VarKind::Const => "var",
                     VarKind::Var => "var",
@@ -151,7 +156,14 @@ impl GoCodegen {
                     .as_ref()
                     .map(|e| format!(" = {}", self.generate_expression(e)))
                     .unwrap_or_else(|| "".to_string());
-                self.add_indentedln(&format!("{} {}{};\n", go_kind, name, init_expr));
+                let type_expr = type_
+                    .clone()
+                    .map(|t| self.translate_type(&t))
+                    .unwrap_or_default();
+                self.add_indentedln(&format!(
+                    "{} {} {}{};\n",
+                    go_kind, name, type_expr, init_expr
+                ));
             }
             Statement::VarAssign { target, value } => {
                 self.add_indentedln(&format!(

parser/src/ast.rs

@@ -67,6 +67,7 @@ pub enum Statement {
         kind: VarKind,
         name: String,
         init: Option<Expression>,
+        type_: Option<TypeExpr>,
     },
 
     VarAssign {

parser/src/grammar.pest

@@ -63,10 +63,10 @@ continue_stmt = { "continue" ~ ";" }
 
 // --- variable declarations ---
 
-var_decl_kind = { "let" | "const" | "var" }
+// var_decl_kind = { "let" | "const" | "var" }
 
 var_decl = {
-    var_decl_kind ~ identifier ~ ("=" ~ expr)? ~ ";"
+    type_expr ~ identifier ~ ("=" ~ expr)? ~ ";"
 }
 
 var_assign = {

parser/src/lib.rs

@@ -43,7 +43,7 @@ impl TryFrom<pest::iterators::Pair<'_, Rule>> for TypeExpr {
                 TypeExpr::try_from(inner)?
             }
             Rule::identifier => TypeExpr::Identifier(pair.as_str().to_string()),
-            _ => unimplemented!("TypeExpr parsing not implemented yet"),
+            _ => unimplemented!("{pair:#?}"),
         })
     }
 }
@@ -188,22 +188,15 @@ impl From<pest::iterators::Pair<'_, Rule>> for Statement {
             Rule::var_decl => {
                 let mut inner = pair.into_inner();
 
-                let kind_pair = inner.next().unwrap(); // let/const/var
+                let type_ = inner.next().map(TypeExpr::try_from).unwrap().ok();
-                let name_pair = inner.next().unwrap(); // identifier
+                let name = inner.next().unwrap().as_str().to_string();
-
                 let init = inner.next().map(Expression::from);
 
-                let kind = match kind_pair.as_str() {
-                    "let" => VarKind::Let,
-                    "const" => VarKind::Const,
-                    "var" => VarKind::Var,
-                    _ => unreachable!(),
-                };
-
                 Statement::VarDecl {
-                    kind,
+                    kind: VarKind::Var,
-                    name: name_pair.as_str().to_string(),
+                    name: name.as_str().to_string(),
                     init,
+                    type_,
                 }
             }
 

parser/src/script_parser.rs

@@ -193,6 +193,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for Statement {
                     kind,
                     name: name_pair.as_str().to_string(),
                     init,
+                    type_: None,
                 }
             }
 

test/src/main.mist

@@ -3,5 +3,6 @@ package main;
 import "fmt";
 
 void main() {
-
+    string test = "Hello, World";
+    fmt.println(test);
 }