feat: implement function call validation and add corresponding tests

Prestgg1 · Prestgg1 · commit ee339c2a6eeb · 2026-05-26T16:38:34.000+04:00
diff --git a/crates/validator/src/expr.rs b/crates/validator/src/expr.rs
@@ -69,6 +69,10 @@ pub fn validate_expr(expr: &mut Expr, ctx: &mut Validator) -> Result<(), Validat
             index,
             target_type,
         } => Ok(()),
+        Expr::Return(e) => {
+            validate_expr(&mut **e, ctx)?;
+            Ok(())
+        }
         Expr::TemplateString(chunk) => {
             for ch in chunk {
                 if let TemplateChunk::Expr(expr) = ch {
diff --git a/crates/validator/src/lib.rs b/crates/validator/src/lib.rs
@@ -103,6 +103,26 @@ impl Validator {
     }
 
     pub fn validate(&mut self, parsed_program: &mut Program) -> Result<(), ValidatorError> {
+        for func in parsed_program.functions.iter_mut() {
+            for param in &func.1.params {
+                self.global_variables.insert(
+                    param.name.clone(),
+                    Symbol {
+                        typ: param.typ.clone(),
+                        is_mutable: param.is_mutable,
+                        is_pointer: param.is_pointer,
+                        is_used: false,
+                        is_changed: false,
+                    },
+                );
+            }
+            for stmt in func.1.body.iter_mut() {
+                validate_statement(stmt, self)?;
+            }
+            for param in &func.1.params {
+                self.global_variables.remove(&param.name);
+            }
+        }
         for expr in parsed_program.expressions.iter_mut() {
             validate_statement(expr, self)?;
         }
diff --git a/crates/validator/src/tests/function_call.rs b/crates/validator/src/tests/function_call.rs
@@ -0,0 +1,59 @@
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use parser::{
+        ast::{Expr, FunctionDef, Parameter, Program, Statement, Symbol},
+        shared_ast::Type,
+    };
+
+    use crate::{Validator, validate};
+
+    #[test]
+    fn function_call_with_argument() {
+        let function = FunctionDef {
+            params: vec![Parameter {
+                name: "a".to_string(),
+                typ: Type::Integer,
+                is_mutable: false,
+                is_pointer: false,
+            }],
+            body: vec![Statement::Expr(Expr::Return(Box::new(Expr::VariableRef {
+                name: "a".to_string(),
+                symbol: None,
+            })))],
+            return_type: Some(Type::Integer),
+        };
+        let mut functions = HashMap::new();
+        functions.insert("Hello".to_string(), function);
+        let mut program = Program {
+            functions,
+            expressions: vec![],
+        };
+
+        let mut validator = Validator::new();
+        validator.validate(&mut program);
+        assert_eq!(
+            program.functions.get("Hello"),
+            Some(&FunctionDef {
+                params: vec![Parameter {
+                    name: "a".to_string(),
+                    typ: Type::Integer,
+                    is_mutable: false,
+                    is_pointer: false,
+                }],
+                body: vec![Statement::Expr(Expr::Return(Box::new(Expr::VariableRef {
+                    name: "a".to_string(),
+                    symbol: Some(Symbol {
+                        typ: Type::Integer,
+                        is_mutable: false,
+                        is_pointer: false,
+                        is_used: true,
+                        is_changed: false,
+                    })
+                })))],
+                return_type: Some(Type::Integer),
+            })
+        )
+    }
+}
diff --git a/crates/validator/src/tests/mod.rs b/crates/validator/src/tests/mod.rs
@@ -1,2 +1,3 @@
 mod assignment;
+mod function_call;
 mod variable_decl;
diff --git a/crates/validator/src/validate.rs b/crates/validator/src/validate.rs
@@ -127,9 +127,11 @@ pub fn validate_statement(stmt: &mut Statement, ctx: &mut Validator) -> Result<(
                     _ => todo!("Bura baxmaq lazımdır {:#?}", function),
                 }
             }
-            _ => todo!("Bura baxmaq lazımdır {:#?}", expr),
+            _ => {
+                return validate_expr(expr, ctx);
+            }
         },
-        _ => todo!("Bura baxmaq lazımdır {:#?}", stmt),
+        _ => todo!("Bura  baxmaq lazımdır {:#?}", stmt),
     }
 
     Ok(())
diff --git a/interpreter/src/runner/binary_op.rs b/interpreter/src/runner/binary_op.rs
@@ -1,12 +1,9 @@
-use parser::{
-    ast::{Expr, Operation},
-    shared_ast::Type,
-};
+use parser::{ast::Operation, shared_ast::Type};
 
 use crate::runner::{Runner, runner::Value};
 //TODO: Burası güncellene bilinir
 pub fn binary_op_runner(
-    ctx: &mut Runner,
+    _ctx: &mut Runner,
     left: Value,
     right: Value,
     op: Operation,
diff --git a/interpreter/src/runner/builtin/mod.rs b/interpreter/src/runner/builtin/mod.rs
@@ -1,12 +1,8 @@
-use parser::{
-    ast::Expr,
-    shared_ast::{BuiltInFunction, Type},
-};
+use parser::shared_ast::{BuiltInFunction, Type};
 
 use crate::runner::{
-    Runner,
     builtin::{input::input, sum::sum},
-    runner::{Value, runner_interpretator},
+    runner::Value,
 };
 
 mod input;
@@ -15,7 +11,7 @@ mod sum;
 pub fn builthin_call_runner(
     function: BuiltInFunction,
     mut args: Vec<Value>,
-    return_type: Type,
+    _return_type: Type,
 ) -> Value {
     match function {
         BuiltInFunction::Print => {
diff --git a/interpreter/src/runner/function_call.rs b/interpreter/src/runner/function_call.rs
@@ -1,7 +1,7 @@
-use std::{os::unix::process, rc::Rc};
+use std::rc::Rc;
 
 use parser::{
-    ast::{Expr, Parameter, Statement, Symbol},
+    ast::{Expr, Statement, Symbol},
     shared_ast::Type,
 };
 
@@ -12,11 +12,12 @@ use crate::runner::{
 
 pub fn function_call(
     ctx: &mut Runner,
-    target: Option<Box<Expr>>,
+    _target: Option<Box<Expr>>,
     name: Box<Expr>,
     args: Vec<Expr>,
-    returned_type: Option<Type>,
+    _returned_type: Option<Type>,
 ) -> Value {
+    dbg!(&name);
     match *name {
         Expr::VariableRef {
             name,
@@ -33,13 +34,14 @@ pub fn function_call(
                         param.name.clone(),
                         Variable {
                             value: variable,
-                            typ: Rc::new(param.typ.clone()),
-                            is_mutable: param.is_mutable,
+                            // typ: Rc::new(param.typ.clone()),
+                            // is_mutable: param.is_mutable,
                         },
                     );
                 }
                 println!("Hellooo");
                 for stmt in function.body.clone() {
+                    dbg!(&stmt);
                     match stmt {
                         Statement::Expr(Expr::Return(e)) => {
                             return get_primitive_value(ctx, *e, function.return_type);
diff --git a/interpreter/src/runner/helpers.rs b/interpreter/src/runner/helpers.rs
@@ -1,5 +1,5 @@
 use crate::runner::{Runner, runner::runner_interpretator};
-use parser::ast::{Expr, Statement};
+use parser::ast::Statement;
 
 /*
  *
@@ -19,7 +19,7 @@ use parser::ast::{Expr, Statement};
 }
 */
 
-pub fn run_body<'a>(ctx: &mut Runner, body: Vec<Statement>) {
+pub fn run_body(ctx: &mut Runner, body: Vec<Statement>) {
     for expr in body {
         runner_interpretator(ctx, expr);
     }
diff --git a/interpreter/src/runner/mod.rs b/interpreter/src/runner/mod.rs
@@ -5,7 +5,7 @@ mod helpers;
 mod runner;
 mod tests;
 use parser::{
-    ast::{Expr, FunctionDef, Parameter, Program, Statement},
+    ast::{Expr, FunctionDef, Statement},
     shared_ast::Type,
 };
 
@@ -16,8 +16,6 @@ mod handlers;
 #[derive(Debug)]
 pub struct Variable {
     value: Value,
-    typ: Rc<Type>,
-    is_mutable: bool,
 }
 
 #[derive(Debug)]
diff --git a/interpreter/src/runner/runner.rs b/interpreter/src/runner/runner.rs
@@ -1,5 +1,5 @@
 use core::{fmt, panic};
-use std::{fmt::Display, rc::Rc};
+use std::fmt::Display;
 
 use super::Runner;
 use crate::runner::{
@@ -8,7 +8,7 @@ use crate::runner::{
 };
 
 use parser::{
-    ast::{Expr, Statement, Symbol, TemplateChunk},
+    ast::{Expr, Statement, TemplateChunk},
     shared_ast::{BuiltInFunction, Type},
 };
 #[derive(Debug, Clone, PartialEq)]
@@ -88,7 +88,7 @@ pub fn get_primitive_value(ctx: &mut Runner, expr: Expr, cast_typ: Option<Type>)
                 .collect(),
         ),
         Expr::Void => Value::Void,
-        Expr::VariableRef { name, symbol } => {
+        Expr::VariableRef { name, symbol: _ } => {
             let var = ctx.variables.get(&name).unwrap();
             var.value.clone()
         }
@@ -111,9 +111,9 @@ pub fn get_primitive_value(ctx: &mut Runner, expr: Expr, cast_typ: Option<Type>)
         Expr::BuiltInCall {
             function,
             args,
-            return_type,
+            return_type: _,
         } => match function {
-            BuiltInFunction::Len => match args.get(0) {
+            BuiltInFunction::Len => match args.first() {
                 Some(current_expr) => {
                     let value = get_primitive_value(ctx, current_expr.clone(), cast_typ);
                     match value {
@@ -149,8 +149,8 @@ pub fn runner_interpretator(ctx: &mut Runner, stmt: Statement) {
                 name.to_string(),
                 Variable {
                     value: new_value,
-                    typ,
-                    is_mutable,
+                    // typ,
+                    // is_mutable,
                 },
             );
         }
diff --git a/interpreter/src/runner/tests/mod.rs b/interpreter/src/runner/tests/mod.rs
@@ -4,7 +4,7 @@ mod tests {
     use std::collections::HashMap;
 
     use parser::{
-        ast::{Expr, FunctionDef, Statement, Symbol},
+        ast::{Expr, FunctionDef, Parameter, Statement, Symbol},
         shared_ast::Type,
     };
 
@@ -45,7 +45,7 @@ mod tests {
         let mut functions = HashMap::new();
         let function = FunctionDef {
             params: vec![],
-            body: vec![Statement::Expr(Expr::Number(1))],
+            body: vec![Statement::Expr(Expr::Return(Box::new(Expr::Number((1)))))],
             return_type: Some(Type::Integer),
         };
         functions.insert("Hello".to_string(), function);
@@ -68,4 +68,47 @@ mod tests {
         );
         assert_eq!(val, Value::Number(1))
     }
+    #[test]
+    fn function_call_return_from_argument() {
+        let mut runner = Runner::new();
+        let mut functions = HashMap::new();
+        let function = FunctionDef {
+            params: vec![Parameter {
+                name: "a".to_string(),
+                typ: Type::Integer,
+                is_mutable: false,
+                is_pointer: false,
+            }],
+            body: vec![Statement::Expr(Expr::Return(Box::new(Expr::VariableRef {
+                name: "a".to_string(),
+                symbol: Some(Symbol {
+                    typ: Type::Integer,
+                    is_mutable: false,
+                    is_pointer: false,
+                    is_used: false,
+                    is_changed: false,
+                }),
+            })))],
+            return_type: Some(Type::Integer),
+        };
+        functions.insert("Hello".to_string(), function);
+        runner.functions = functions;
+        let val = function_call(
+            &mut runner,
+            None,
+            Box::new(Expr::VariableRef {
+                name: "Hello".to_string(),
+                symbol: Some(Symbol {
+                    typ: Type::Function,
+                    is_mutable: false,
+                    is_pointer: false,
+                    is_used: false,
+                    is_changed: false,
+                }),
+            }),
+            vec![Expr::Number(1)],
+            Some(Type::Integer),
+        );
+        assert_eq!(val, Value::Number(1))
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,3 @@`
`1`	`1`	`mod assignment;`
	`2`	`+mod function_call;`
`2`	`3`	`mod variable_decl;`
Original file line number	Diff line number	Diff line change
`@@ -127,9 +127,11 @@ pub fn validate_statement(stmt: &mut Statement, ctx: &mut Validator) -> Result<(`
`127`	`127`	`_ => todo!("Bura baxmaq lazımdır {:#?}", function),`
`128`	`128`	`}`
`129`	`129`	`}`
`130`		`- _ => todo!("Bura baxmaq lazımdır {:#?}", expr),`
	`130`	`+ _ => {`
	`131`	`+ return validate_expr(expr, ctx);`
	`132`	`+ }`
`131`	`133`	`},`
`132`		`- _ => todo!("Bura baxmaq lazımdır {:#?}", stmt),`
	`134`	`+ _ => todo!("Bura baxmaq lazımdır {:#?}", stmt),`
`133`	`135`	`}`
`134`	`136`
`135`	`137`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`use crate::runner::{Runner, runner::runner_interpretator};`
`2`		`-use parser::ast::{Expr, Statement};`
	`2`	`+use parser::ast::Statement;`
`3`	`3`
`4`	`4`	`/*`
`5`	`5`	`*`
`@@ -19,7 +19,7 @@ use parser::ast::{Expr, Statement};`
`19`	`19`	`}`
`20`	`20`	`*/`
`21`	`21`
`22`		`-pub fn run_body<'a>(ctx: &mut Runner, body: Vec<Statement>) {`
	`22`	`+pub fn run_body(ctx: &mut Runner, body: Vec<Statement>) {`
`23`	`23`	`for expr in body {`
`24`	`24`	`runner_interpretator(ctx, expr);`
`25`	`25`	`}`