Support return statements in AST, function declerations in grammar, add full file parsing tests

.idea/micro_script.iml

@@ -7,6 +7,7 @@
       <sourceFolder url="file://$MODULE_DIR$/forge-script-web/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/forge-script/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/forge-script-lang/tests" isTestSource="true" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
     </content>
     <orderEntry type="inheritedJdk" />

forge-script-lang/src/parser/ast.rs

@@ -7,13 +7,21 @@ pub trait AstNode {}
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct Program(pub ExpressionList);
 impl AstNode for Program {}
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct ExpressionList {
 	pub expressions: Vec<Expression>,
 	pub is_void: bool,
@@ -155,11 +163,16 @@ pub enum VoidExpression {
 	Import(Import),
 	Export(Export),
 	Print(Print),
+	Return(Return),
 }
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct GroupedExpression {
 	pub inner: Box<ValueExpression>,
 }
@@ -297,12 +310,20 @@ impl ValueExpression {
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct TypeofValue(pub Box<ValueExpression>);
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct ConditionalLoop {
 	pub block: GuardedBlock,
 	pub fallback: Option<ExpressionList>,
@@ -325,7 +346,11 @@ impl ConditionalLoop {
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct Conditional {
 	pub blocks: Vec<GuardedBlock>,
 	pub fallback: Option<ExpressionList>,
@@ -333,7 +358,11 @@ pub struct Conditional {
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct GuardedBlock {
 	pub guard: Box<ValueExpression>,
 	pub block: ExpressionList,
@@ -341,7 +370,11 @@ pub struct GuardedBlock {
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct Import {
 	pub source: String,
 	pub items: IdentifierList,
@@ -349,14 +382,22 @@ pub struct Import {
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct Export {
 	pub items: IdentifierList,
 }
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct Print {
 	pub expr: Box<ValueExpression>,
 }
@@ -368,12 +409,34 @@ impl From<ValueExpression> for Print {
 	}
 }
 
+#[derive(Clone)]
+#[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
+pub struct Return {
+	pub expr: Box<ValueExpression>,
+}
+impl From<ValueExpression> for Return {
+	fn from(value: ValueExpression) -> Self {
+		Return {
+			expr: Box::new(value),
+		}
+	}
+}
+
 pub type IdentifierList = Vec<IdentifierNode>;
 pub type ParameterList = Vec<ValueExpression>;
 
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct Identifier(pub String);
 impl Display for Identifier {
 	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
@@ -385,7 +448,11 @@ impl Display for Identifier {
 /// IdentifierAlias(original, alias) => identifier "as" alias
 #[derive(Clone)]
 #[cfg_attr(any(feature = "debug-ast", test), derive(Debug))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde::Serialize, serde::Deserialize),
+	serde(rename_all = "snake_case")
+)]
 pub struct IdentifierAlias(pub String, pub String);
 impl Display for IdentifierAlias {
 	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
@@ -568,5 +635,6 @@ impl_into_void_expr!(
 	Print => VoidExpression::Print,
 	ConditionalLoop => VoidExpression::ConditionLoop,
 	Import => VoidExpression::Import,
-	Export => VoidExpression::Export
+	Export => VoidExpression::Export,
+	Return => VoidExpression::Return
 );

forge-script-lang/src/parser/forge_grammar.lalrpop

@@ -25,18 +25,22 @@ ExpressionList: ExpressionList = {
     },
 }
 
+FunctionDeclParamList = CommaSeperatedList<FunctionDeclParam>;
+
+FunctionDeclParam: DeclareIdent = {
+    Identifier => DeclareIdent::WithoutValue(<>),
+    <id:Identifier> "=" <def:ValueExpression> => DeclareIdent::WithValue(Assignment {
+        ident: id,
+        value: Box::new(def),
+    }),
+}
+
 ParameterList: Vec<ValueExpression> = {
     "(" <CommaSeperatedValueExpressionList> ")" => <>,
     "(" ")" => Vec::new(),
 }
 
-CommaSeperatedValueExpressionList: Vec<ValueExpression> = {
-    ValueExpression => vec![<>],
-    <mut ls:CommaSeperatedValueExpressionList> "," <ve:ValueExpression> => {
-        ls.push(ve);
-        ls
-    },
-}
+CommaSeperatedValueExpressionList = CommaSeperatedList<ValueExpression>;
 
 pub Expression: Expression = {
     ValueExpression => Expression::Value(<>),
@@ -44,9 +48,9 @@ pub Expression: Expression = {
 }
 
 ValueExpression: ValueExpression = {
-    BoolOrExpression => <>,
+    FirstClassDeclareExpression => <>,
     "let" <Identifier> => DeclareIdent::WithoutValue(<>).into(),
-    "let" <id:Identifier> "=" <expr:BoolOrExpression> => DeclareIdent::WithValue(
+    "let" <id:Identifier> "=" <expr:FirstClassDeclareExpression> => DeclareIdent::WithValue(
         Assignment { ident: id, value :Box::new(expr) }
     ).into(),
 }
@@ -55,6 +59,11 @@ VoidExpression: VoidExpression = {
     UnaryStatement => <>
 }
 
+FirstClassDeclareExpression: ValueExpression = {
+    BoolOrExpression => <>,
+    DeclareFunction => <>.into(),
+}
+
 BoolOrExpression: ValueExpression = {
     BoolAndExpression => <>,
     <lhs:BoolOrExpression> "||" <rhs:BoolAndExpression> => ValueExpression::bool_or(lhs, rhs),
@@ -93,7 +102,8 @@ MultiplicativeExpression: ValueExpression = {
 }
 
 UnaryStatement: VoidExpression = {
-    "print" <UnaryExpression> => Print { expr: Box::new(<>) }.into(),
+    "print" <FirstClassDeclareExpression> => Print { expr: Box::new(<>) }.into(),
+    "return" <FirstClassDeclareExpression> => Return { expr: Box::new(<>) }.into(),
 }
 
 UnaryExpression: ValueExpression = {
@@ -123,6 +133,14 @@ BaseExpression: ValueExpression = {
     "(" <ValueExpression> ")" => GroupedExpression { inner: Box::new(<>) }.into(),
 }
 
+DeclareFunction: DeclareFunction = {
+    "fn" <ident:Identifier> "(" <params:FunctionDeclParamList?> ")" <body:ExpressionBlock> => DeclareFunction {
+        ident,
+        params: params.unwrap_or_default(),
+        body,
+    }
+}
+
 AccessorChainAnyEnding: Vec<AccessorType> = {
     AccessorChainEndingWithProperty => <>,
     FunctionCall => vec![AccessorType::FunctionCall(<>)],
@@ -198,6 +216,14 @@ StringValue: String = {
     "owned_string" => <>,
 };
 
+CommaSeperatedList<Type>: Vec<Type> = {
+    Type => vec![<>],
+    <mut ls:CommaSeperatedList<Type>> "," <ty:Type> => {
+        ls.push(ty);
+        ls
+    }
+}
+
 extern {
     type Location = usize;
     type Error = String;
@@ -212,6 +238,7 @@ extern {
         "-" => ScriptTokenType::Minus,
         "+" => ScriptTokenType::Plus,
         ";" => ScriptTokenType::Semicolon,
+        ":" => ScriptTokenType::Colon,
         "/" => ScriptTokenType::Slash,
         "*" => ScriptTokenType::Asterisk,
         "!" => ScriptTokenType::Bang,

forge-script-lang/src/parser/forge_script.rs

@@ -56,6 +56,10 @@ mod grammar_test {
 	#[test_case("foo.bar().baz" => matches Ok(_) ; "nested property accessor")]
 	#[test_case("if something_else {}.bar" => matches Ok(_) ; "expression property accessor")]
 	#[test_case("123 + if if foo { bar } else { baz } { 200 } else { 300 }" => matches Ok(_) ; "Parse inline condition")]
+	#[test_case("fn add(a, b) { a + b }" => matches Ok(_) ; "Declare basic fn")]
+	#[test_case("fn has_no_params() {}" => matches Ok(_) ; "Declare empty params fn")]
+	#[test_case("fn do_some_stuff(foo = 123, bar, baz = \"My Default String\") {}" => matches Ok(_) ; "Declare complex fn")]
+	#[test_case("let som_value = fn do_some_stuff(foo = 123, bar, baz = \"My Default String\") {}" => matches Ok(_) ; "First class fn")]
 	fn expression_parsing(prog: &str) -> Result<Expression, String> {
 		parse_expression(prog).map(|expr| {
 			dbg!(&expr);

forge-script-lang/src/runtime/executor/printer.rs

@@ -268,6 +268,10 @@ impl Visitor for TreePrinter {
 				self.write("print ");
 				self.evaluate_value_expression(print.expr.as_ref());
 			}
+			VoidExpression::Return(ret) => {
+				self.write("return ");
+				self.evaluate_value_expression(ret.expr.as_ref());
+			}
 		}
 
 		Ok(())

forge-script-lang/src/runtime/executor/simple.rs

 use crate::parse::ast::{
-	BinaryOp, DeclareFunction, DeclareIdent, ExpressionList, Print, Program, UnaryOp,
+	BinaryOp, DeclareFunction, DeclareIdent, ExpressionList, Print, Program, Return, UnaryOp,
 	ValueExpression, VoidExpression,
 };
 use crate::parser::ast::Assignment;
@@ -241,6 +241,10 @@ impl Visitor for SimpleExecutor {
 				let value = self.evaluate_value_expression(expr.as_ref())?;
 				println!("{}", value);
 			}
+			VoidExpression::Return(Return { expr }) => {
+				let value = self.evaluate_value_expression(expr.as_ref())?;
+				eprintln!("Currently Unsupported: Return. Value: {}", value);
+			}
 		}
 
 		Ok(ForgeValue::Null)

forge-script-lang/src/runtime/vm/chunk_builder.rs

@@ -124,6 +124,7 @@ impl Visitor for ChunkBuilder {
 			VoidExpression::Import(_) => Err(VmError::chunk_parser("Unsupported expression")),
 			VoidExpression::Export(_) => Err(VmError::chunk_parser("Unsupported expression")),
 			VoidExpression::Print(_) => Err(VmError::chunk_parser("Unsupported expression")),
+			VoidExpression::Return(_) => Err(VmError::chunk_parser("Unsupported expression")),
 		}
 	}
 

forge-script-lang/tests/cases/basic_maths.fs

+2 + 2;
+3 + 3 - 4 * 5;
+3 + (3 - 2);
+4+4+4 + 4   +   4         +               4;

forge-script-lang/tests/cases/conditionals.fs

+import { random_float, random_int, random_bool } from "@runtime:random"
+import { truncate } from "@runtime:maths"
+
+let var_a = random_int(0, 10) >= 5;
+let var_b = random_bool();
+let my_var = if if 1 + 2 > 4 { var_a } else { var_b } {
+    truncate(random_float() * 10)
+} else {
+    random_int(100, 200)
+};
\ No newline at end of file

forge-script-lang/tests/cases/declare_items.fs

+let foo;
+let bar = 123 + foo;
+
+fn my_func() {
+    let foo;
+    let bar = 123 + foo;
+};
+
+let other_name = fn some_internal_name(a, b = 2) {
+    a * b
+};
+
+fn has_early_return(a, b, c) {
+    if b {
+        return false;
+    };
+
+    a + c
+}
\ No newline at end of file

forge-script-lang/tests/program_tests.rs

+use forge_script_lang::parse::{parse_expression, parse_program};
+use std::path::PathBuf;
+
+fn get_base_path() -> Result<PathBuf, std::io::Error> {
+	let mut cwd = std::env::current_dir()?;
+	let mut path = PathBuf::from(file!());
+	cwd.pop();
+	path.pop();
+	path.push("cases");
+	Ok(cwd.join(path))
+}
+
+fn iterate_files() -> Result<Vec<PathBuf>, std::io::Error> {
+	let base = get_base_path()?;
+	let mut files = Vec::with_capacity(10);
+	for file in std::fs::read_dir(base.display().to_string())? {
+		let entry = file?;
+		files.push(entry.path());
+	}
+
+	Ok(files)
+}
+
+fn read_and_parse(path: PathBuf) -> Result<(), std::io::Error> {
+	let file = std::fs::read_to_string(path)?;
+	parse_program(file.as_str()).expect("Failed to parse");
+	Ok(())
+}
+
+#[test]
+fn parse_all_programs() -> Result<(), std::io::Error> {
+	for file in iterate_files()?.into_iter() {
+		read_and_parse(file)?;
+	}
+	Ok(())
+}