fix possible memory leak

cyteon · cyteon · commit ffff92a75b8c · 2026-03-21T17:19:34.000+01:00
diff --git a/lang/src/cli/repl.rs b/lang/src/cli/repl.rs
@@ -127,6 +127,7 @@ pub fn repl() {
                     let ast = parse(&buffer, "<repl>");
         
                     if let Err(_) = ast {
+                        buffer.clear();
                         continue;
                     }
 
@@ -135,6 +136,7 @@ pub fn repl() {
                     
                     if let Err(e) = compiler.compile_program(ast.clone().unwrap()) {
                         println!("{}: {}", "Compilation error".red(), e);
+                        buffer.clear();
                         continue;
                     }
 
diff --git a/lang/src/compiler/compiler.rs b/lang/src/compiler/compiler.rs
@@ -38,6 +38,13 @@ impl Compiler {
         )
     }
 
+    fn block_is_void(expr: &Expr) -> bool {
+        match expr {
+            Expr::Block(exprs) => exprs.last().map(|e| Self::is_void(&e.node)).unwrap_or(true),
+            _ => false,
+        }
+    }
+
     // chunk shit
 
     fn emit(&mut self, instruction: Instruction, span: SimpleSpan) {
@@ -348,8 +355,12 @@ impl Compiler {
 
             Expr::And(a, b) => {
                 self.compile_expr(*a.clone())?;
+                
+                let skip = self.emit_jump(Instruction::JumpIfFalse(0), span);
+                self.emit(Instruction::Pop, span);
+
                 self.compile_expr(*b.clone())?;
-                self.emit(Instruction::And, span);
+                self.patch_jump(skip);
             }
 
             Expr::Or(a, b) => {
@@ -396,6 +407,11 @@ impl Compiler {
                 self.continue_targets.push(start);
 
                 self.compile_expr(*body.clone())?;
+
+                if !Self::block_is_void(&body.node) {
+                    self.emit(Instruction::Pop, span);
+                }
+
                 self.emit(Instruction::Jump(start), span);
 
                 let breaks = self.break_patches.pop().unwrap();
@@ -415,6 +431,11 @@ impl Compiler {
                 let exit = self.emit_jump(Instruction::JumpIfFalse(0), span);
 
                 self.compile_expr(*body.clone())?;
+
+                if !Self::block_is_void(&body.node) {
+                    self.emit(Instruction::Pop, span);
+                }
+
                 self.emit(Instruction::Jump(start), span);
 
                 let breaks = self.break_patches.pop().unwrap();
@@ -469,6 +490,11 @@ impl Compiler {
                 
                 // body
                 self.compile_expr(*body.clone())?;
+
+                if !Self::block_is_void(&body.node) {
+                    self.emit(Instruction::Pop, span);
+                }
+
                 self.emit(Instruction::Jump(start), span);
 
                 self.patch_jump(exit);
diff --git a/lang/src/functions.rs b/lang/src/functions.rs
@@ -87,6 +87,7 @@ fn int(args: Vec<Value>) -> Result<Value, String> {
     }
 
     match &args[0] {
+        Value::Int(i) => Ok(Value::Int(*i)),
         Value::Float(f) => Ok(Value::Int(*f as i64)),
         Value::Bool(b) => Ok(Value::Int(if *b { 1 } else { 0 })),
         Value::String(s) => s.parse::<i64>()
@@ -103,6 +104,7 @@ fn float(args: Vec<Value>) -> Result<Value, String> {
     }
 
     match &args[0] {
+        Value::Float(f) => Ok(Value::Float(*f)),
         Value::Int(i) => Ok(Value::Float(*i as f64)),
         Value::Bool(b) => Ok(Value::Float(if *b { 1.0 } else { 0.0 })),
         Value::String(s) => s.parse::<f64>()
diff --git a/lang/src/natives/array.rs b/lang/src/natives/array.rs
@@ -15,7 +15,16 @@ pub fn get_fn(name: String) -> Option<NativeFn> {
 }
 
 pub fn list_fns() -> Vec<String> {
-    vec!["len".to_string(), "push".to_string(), "pop".to_string(), "join".to_string()]
+    vec![
+        "len".to_string(),
+        "push".to_string(), 
+        "pop".to_string(), 
+        "join".to_string(),
+        "min".to_string(),
+        "max".to_string(),
+        "reverse".to_string(),
+        "sort".to_string()
+    ]
 }
 
 pub fn len(this: Value, args: Vec<Value>) -> Result<(Value, Option<Value>), String> {
@@ -86,8 +95,21 @@ pub fn min(this: Value, args: Vec<Value>) -> Result<(Value, Option<Value>), Stri
 
     match this {
         Value::Array(arr) => {
-            let min_value = arr.iter().min_by(|a, b| a.partial_cmp(b).unwrap()).cloned().unwrap_or(Value::Null);
-            Ok((min_value, None))
+            if arr.is_empty() {
+                return Ok((Value::Null, None));
+            }
+
+            let mut min_value = &arr[0];
+
+            for v in &arr[1..] {
+                match v.partial_cmp(min_value) {
+                    Some(std::cmp::Ordering::Less) => min_value = v,
+                    None => return Err(format!("cannot compare '{}' and '{}'", v.type_name(), min_value.type_name())),
+                    _ => {}
+                }
+            }
+
+            Ok((min_value.clone(), None))
         }
 
         _ => unreachable!(),
@@ -101,8 +123,21 @@ pub fn max(this: Value, args: Vec<Value>) -> Result<(Value, Option<Value>), Stri
 
     match this {
         Value::Array(arr) => {
-            let max_value = arr.iter().max_by(|a, b| a.partial_cmp(b).unwrap()).cloned().unwrap_or(Value::Null);
-            Ok((max_value, None))
+            if arr.is_empty() {
+                return Ok((Value::Null, None));
+            }
+
+            let mut max_value = &arr[0];
+
+            for v in &arr[1..] {
+                match v.partial_cmp(max_value) {
+                    Some(std::cmp::Ordering::Greater) => max_value = v,
+                    None => return Err(format!("cannot compare '{}' and '{}'", v.type_name(), max_value.type_name())),
+                    _ => {}
+                }
+            }
+
+            Ok((max_value.clone(), None))
         }
 
         _ => unreachable!(),
diff --git a/lang/src/validator.rs b/lang/src/validator.rs
@@ -58,7 +58,9 @@ fn validate_expr(expr: &SpannedExpr, ctx: &mut ValidationContext) -> Result<(),
         }
 
         Expr::Function { body, .. } => {
+            ctx.inside_function += 1;
             validate_expr(&body, ctx)?;
+            ctx.inside_function -= 1;
         }
 
         Expr::WhileLoop { body, .. } | Expr::ForLoop { body, .. } | Expr::InfiniteLoop { body, .. } => {
@@ -78,11 +80,9 @@ fn validate_expr(expr: &SpannedExpr, ctx: &mut ValidationContext) -> Result<(),
         }
 
         Expr::Block(body) => {
-            ctx.inside_function += 1;
             for expr in body {
                 validate_expr(&expr, ctx)?;
             }
-            ctx.inside_function -= 1;
         }
 
         _ => {}

Original file line number	Diff line number	Diff line change
`@@ -127,6 +127,7 @@ pub fn repl() {`
`127`	`127`	`let ast = parse(&buffer, "<repl>");`
`128`	`128`
`129`	`129`	`if let Err(_) = ast {`
	`130`	`+ buffer.clear();`
`130`	`131`	`continue;`
`131`	`132`	`}`
`132`	`133`
`@@ -135,6 +136,7 @@ pub fn repl() {`
`135`	`136`
`136`	`137`	`if let Err(e) = compiler.compile_program(ast.clone().unwrap()) {`
`137`	`138`	`println!("{}: {}", "Compilation error".red(), e);`
	`139`	`+ buffer.clear();`
`138`	`140`	`continue;`
`139`	`141`	`}`
`140`	`142`
Original file line number	Diff line number	Diff line change
`@@ -87,6 +87,7 @@ fn int(args: Vec<Value>) -> Result<Value, String> {`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`match &args[0] {`
	`90`	`+ Value::Int(i) => Ok(Value::Int(*i)),`
`90`	`91`	`Value::Float(f) => Ok(Value::Int(*f as i64)),`
`91`	`92`	`Value::Bool(b) => Ok(Value::Int(if *b { 1 } else { 0 })),`
`92`	`93`	`Value::String(s) => s.parse::<i64>()`
`@@ -103,6 +104,7 @@ fn float(args: Vec<Value>) -> Result<Value, String> {`
`103`	`104`	`}`
`104`	`105`
`105`	`106`	`match &args[0] {`
	`107`	`+ Value::Float(f) => Ok(Value::Float(*f)),`
`106`	`108`	`Value::Int(i) => Ok(Value::Float(*i as f64)),`
`107`	`109`	`Value::Bool(b) => Ok(Value::Float(if *b { 1.0 } else { 0.0 })),`
`108`	`110`	`Value::String(s) => s.parse::<f64>()`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,9 @@ fn validate_expr(expr: &SpannedExpr, ctx: &mut ValidationContext) -> Result<(),`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`Expr::Function { body, .. } => {`
	`61`	`+ ctx.inside_function += 1;`
`61`	`62`	`validate_expr(&body, ctx)?;`
	`63`	`+ ctx.inside_function -= 1;`
`62`	`64`	`}`
`63`	`65`
`64`	`66`	`Expr::WhileLoop { body, .. } \| Expr::ForLoop { body, .. } \| Expr::InfiniteLoop { body, .. } => {`
`@@ -78,11 +80,9 @@ fn validate_expr(expr: &SpannedExpr, ctx: &mut ValidationContext) -> Result<(),`
`78`	`80`	`}`
`79`	`81`
`80`	`82`	`Expr::Block(body) => {`
`81`		`- ctx.inside_function += 1;`
`82`	`83`	`for expr in body {`
`83`	`84`	`validate_expr(&expr, ctx)?;`
`84`	`85`	`}`
`85`		`- ctx.inside_function -= 1;`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`_ => {}`