remove builtin functions, add AzLang-Std submodule, unified print with ValueType

Author: Prestgg1

.gitignore

@@ -7,3 +7,6 @@ bin/*
 diff.txt
 zig-cache/
 .zig-cache/
+
+# SDK - tracked as separate submodule
+sdk/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "sdk"]
+	path = sdk
+	url = git@github.com:AzLangProgramingLanguage/AzLang-Std.git

compiler/src/lib.rs

@@ -42,27 +42,14 @@ fn bin_create_dir() -> Result<PathBuf, FileSystemError> {
         fs::create_dir(bin_path)?;
     }
     let zig_path = get_zig_path();
-    // dbg!(
-    //     Command::new(zig_path)
-    //         .arg("init")
-    //         .current_dir("./bin")
-    //         .get_current_dir()
-    // );
-    let output = Command::new("ls")
-        .arg("-la")
-        .current_dir("./bin") // Sets the working directory
-        .output()
-        .expect("Failed to execute command");
-
-    println!("{}", String::from_utf8_lossy(&output.stdout));
-    assert!(false);
+    Command::new(zig_path).arg("init").current_dir("./bin");
     let deps_src = Path::new("./dependencies");
     let deps_dest = bin_path.join("dependencies");
     if deps_src.exists() {
         copy_dir_all(deps_src, &deps_dest)?;
     }
 
-    Ok(bin_path.join("main.zig"))
+    Ok(bin_path.join("src/main.zig"))
 }
 
 fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> Result<(), FileSystemError> {

compiler/src/tests/compiler_test.rs

@@ -3,7 +3,8 @@ use transpiler::TranspileContext;
 
 #[test]
 fn compiler_variable_test() {
-    let sdk = file_system::read_file("../examples/float.az").expect("Fayl oxunamadı");
+    const PATH: &str = "../examples/float.az";
+    let sdk = file_system::read_file(PATH).expect("Fayl oxunamadı");
 
     let parsed_program = parser(sdk).expect("Parse oluna bilinmedi ");
 
@@ -22,7 +23,7 @@ fn compiler_variable_test() {
         std::process::exit(err.code());
     });
 
-    build(output_zig.to_str().unwrap(), "../examples/float.az").expect("Build oluna bilinmedi");
+    build(output_zig.to_str().unwrap(), PATH).expect("Build oluna bilinmedi");
 }
 #[test]
 fn compiler_binary_op_test() {

crates/parser/src/ast.rs

@@ -1,4 +1,4 @@
-use crate::shared_ast::{BuiltInFunction, Type};
+use crate::shared_ast::Type;
 use core::fmt;
 use std::{
     collections::HashMap,
@@ -182,10 +182,6 @@ pub enum Expr {
     },
     TemplateString(Vec<TemplateChunk>),
 
-    BuiltInCall {
-        function: BuiltInFunction,
-        args: Vec<Expr>,
-    },
     Call {
         target: Option<Box<Expr>>,
         name: Box<Expr>,

crates/parser/src/binary_op.rs

@@ -82,7 +82,7 @@ fn parse_binary_op_with_precedence(
                     return Err(ParserError::RParenNotFound(Token::Eof));
                 }
                 _ => {
-                    args.push(parse_single_expr(tokens)?);
+                    args.push(parse_expression(tokens)?);
                 }
             }
         }

crates/parser/src/builtin.rs

@@ -10,7 +10,6 @@ pub enum ParserError {
     UnexpectedEOF,
     NotUserDirectValue,
     MethodNameNotFound(Token),
-    UnsupportedBuiltInFunction(Token),
     ExpectedToken(Token, Token),
     LoopVarNameNotFound(Token),
     StructNameNotFound(Token),
@@ -51,9 +50,6 @@ impl Display for ParserError {
                     "Metod və ya sahə adı gözlənilirdi amma bu tapıldı: '{token}'"
                 )
             }
-            ParserError::UnsupportedBuiltInFunction(token) => {
-                write!(f, "Dəstəklənməyən funksiya: '{token}'")
-            }
             ParserError::ExpectedToken(expected, found) => {
                 write!(f, "Gözlənilirdi '{expected}', tapıldı '{found}'")
             }

crates/parser/src/errors.rs

@@ -3,7 +3,6 @@ use std::collections::HashMap;
 use crate::{
     ast::{Expr, Operation, Statement},
     binary_op::{parse_expression, parse_statement},
-    builtin::parse_builtin,
     errors::ParserError,
     function::parse_function_def,
     identifier::parse_identifier,
@@ -100,84 +99,7 @@ pub fn parse_single_expr(tokens: &mut Tokens) -> Result<Expr, ParserError> {
             ..
         } => Ok(Expr::Continue),
 
-        SpannedToken {
-            token: Token::Print,
-            ..
-        }
-        | SpannedToken {
-            token: Token::Input,
-            ..
-        }
-        | SpannedToken {
-            token: Token::Len, ..
-        }
-        | SpannedToken {
-            token: Token::NumberFn,
-            ..
-        }
-        | SpannedToken {
-            token: Token::Sum, ..
-        }
-        | SpannedToken {
-            token: Token::RangeFn,
-            ..
-        }
-        | SpannedToken {
-            token: Token::LastWord,
-            ..
-        }
-        | SpannedToken {
-            token: Token::Sqrt, ..
-        }
-        | SpannedToken {
-            token: Token::Timer,
-            ..
-        }
-        | SpannedToken {
-            token: Token::Max, ..
-        }
-        | SpannedToken {
-            token: Token::StrUpper,
-            ..
-        }
-        | SpannedToken {
-            token: Token::StrLower,
-            ..
-        }
-        | SpannedToken {
-            token: Token::Min, ..
-        }
-        | SpannedToken {
-            token: Token::Zig, ..
-        }
-        | SpannedToken {
-            token: Token::Mod, ..
-        }
-        | SpannedToken {
-            token: Token::Trim, ..
-        }
-        | SpannedToken {
-            token: Token::StrReverse,
-            ..
-        }
-        | SpannedToken {
-            token: Token::ConvertString,
-            ..
-        }
-        | SpannedToken {
-            token: Token::Round,
-            ..
-        }
-        | SpannedToken {
-            token: Token::Floor,
-            ..
-        }
-        | SpannedToken {
-            token: Token::Ceil, ..
-        } => {
-            let result = parse_builtin(token, tokens)?;
-            Ok(result)
-        }
+
         SpannedToken {
             token: Token::Backtick,
             ..

crates/parser/src/expressions.rs

@@ -78,7 +78,7 @@ pub fn parse_external_function_def(tokens: &mut Tokens) -> Result<Statement, Par
                 if matches!(tok.token, Token::MutableDecl | Token::ConstantDecl) {
                     tokens.next();
                 }
-                let param_type = parse_type(tokens)?;
+                let param_type = param_typ(tokens, is_mutable)?;
                 let param_name = match tokens.next() {
                     Some(SpannedToken {
                         token: Token::Identifier(s),
@@ -180,7 +180,8 @@ pub fn parse_function_def(tokens: &mut Tokens) -> Result<Statement, ParserError>
                 if matches!(tok.token, Token::MutableDecl | Token::ConstantDecl) {
                     tokens.next();
                 }
-                let param_type = parse_type(tokens)?;
+                let param_typ = param_typ(tokens, is_mutable)?;
+
                 let param_name = match tokens.next() {
                     Some(SpannedToken {
                         token: Token::Identifier(s),
@@ -192,7 +193,7 @@ pub fn parse_function_def(tokens: &mut Tokens) -> Result<Statement, ParserError>
                 };
                 params.push(Parameter {
                     name: param_name,
-                    typ: param_type,
+                    typ: param_typ,
                     is_pointer: is_mutable,
                 });
                 match tokens.peek() {
@@ -254,3 +255,13 @@ pub fn parse_function_def(tokens: &mut Tokens) -> Result<Statement, ParserError>
         params,
     })
 }
+fn param_typ(tokens: &mut Tokens, is_mutable: bool) -> Result<Type, ParserError> {
+    let mut param_type = parse_type(tokens)?;
+    match (&param_type, &is_mutable) {
+        (Type::String(S), false) => {
+            param_type = Type::String(crate::shared_ast::StringEnum::LiteralConstString);
+        }
+        _ => {}
+    }
+    Ok(param_type)
+}