feat: integrate stdlib IO with expression calls and complete type checking for new constructs + demo .rpy file

RafaelLopes23 · RafaelLopes23 · commit 248c7aa08730 · 2025-12-11T13:07:16.000-03:00
diff --git a/examples/hello_io.rpy b/examples/hello_io.rpy
@@ -0,0 +1,4 @@
+var _ = print("Hello from R-Python");
+var _ = print("2 + 3 = ");
+var resultado = 2 + 3;
+var _ = print(resultado);
diff --git a/src/interpreter/expression_eval.rs b/src/interpreter/expression_eval.rs
@@ -1,6 +1,7 @@
 use super::statement_execute::Computation;
 use crate::environment::environment::Environment;
-use crate::ir::ast::{Expression, Name};
+use crate::ir::ast::{Expression, Name, Statement};
+use crate::stdlib::standard_library::get_metabuiltins_table;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum ExpressionResult {
@@ -422,7 +423,125 @@ pub fn eval_function_call(
                 Err(e) => Err(e),
             }
         }
-        _ => Err(format!("Function {} not found", name)),
+        None => {
+            // Se não for função definida pelo usuário, tenta despachar para a stdlib
+            let table = get_metabuiltins_table();
+            if let Some(meta_fn) = table.get(&name) {
+                let mut meta_env: Environment<Expression> = Environment::new();
+
+                match name.as_str() {
+                    // input([prompt]) -> String
+                    "input" => {
+                        if let Some(prompt_expr) = args.get(0) {
+                            let prompt_val = match eval(prompt_expr.clone(), env)? {
+                                ExpressionResult::Value(Expression::CString(s)) => {
+                                    Expression::CString(s)
+                                }
+                                ExpressionResult::Value(v) => {
+                                    // Fallback simples: usa Debug para montar string
+                                    Expression::CString(format!("{:?}", v))
+                                }
+                                ExpressionResult::Propagate(e) => {
+                                    return Ok(ExpressionResult::Propagate(e))
+                                }
+                            };
+                            meta_env.map_variable("prompt".to_string(), false, prompt_val);
+                        }
+
+                        let stmt = meta_fn(&mut meta_env);
+                        if let Statement::Return(expr) = stmt {
+                            Ok(ExpressionResult::Value(*expr))
+                        } else {
+                            Err("[Runtime Error] input builtin did not return a value".into())
+                        }
+                    }
+
+                    // print(value) -> Unit, com efeito em stdout
+                    "print" => {
+                        if args.len() != 1 {
+                            return Err("[Runtime Error] print expects exactly 1 argument".into());
+                        }
+                        let val = match eval(args[0].clone(), env)? {
+                            ExpressionResult::Value(v) => v,
+                            ExpressionResult::Propagate(e) => {
+                                return Ok(ExpressionResult::Propagate(e))
+                            }
+                        };
+                        meta_env.map_variable("value".to_string(), false, val);
+                        let _ = meta_fn(&mut meta_env);
+                        Ok(ExpressionResult::Value(Expression::CVoid))
+                    }
+
+                    // open(path, [mode], [content]) -> String ou Unit
+                    "open" => {
+                        if args.is_empty() {
+                            return Err(
+                                "[Runtime Error] open expects at least 1 argument (path)".into()
+                            );
+                        }
+
+                        // path
+                        let path_val = match eval(args[0].clone(), env)? {
+                            ExpressionResult::Value(Expression::CString(s)) => {
+                                Expression::CString(s)
+                            }
+                            ExpressionResult::Value(_) => {
+                                return Err("[Runtime Error] open path must be a string".into());
+                            }
+                            ExpressionResult::Propagate(e) => {
+                                return Ok(ExpressionResult::Propagate(e))
+                            }
+                        };
+                        meta_env.map_variable("path".to_string(), false, path_val);
+
+                        // mode (opcional)
+                        if args.len() >= 2 {
+                            let mode_val = match eval(args[1].clone(), env)? {
+                                ExpressionResult::Value(Expression::CString(s)) => {
+                                    Expression::CString(s)
+                                }
+                                ExpressionResult::Value(_) => {
+                                    return Err("[Runtime Error] open mode must be a string".into());
+                                }
+                                ExpressionResult::Propagate(e) => {
+                                    return Ok(ExpressionResult::Propagate(e))
+                                }
+                            };
+                            meta_env.map_variable("mode".to_string(), false, mode_val);
+                        }
+
+                        // content (opcional, para 'w' / 'a')
+                        if args.len() >= 3 {
+                            let content_val = match eval(args[2].clone(), env)? {
+                                ExpressionResult::Value(Expression::CString(s)) => {
+                                    Expression::CString(s)
+                                }
+                                ExpressionResult::Value(_) => {
+                                    return Err(
+                                        "[Runtime Error] open content must be a string".into()
+                                    );
+                                }
+                                ExpressionResult::Propagate(e) => {
+                                    return Ok(ExpressionResult::Propagate(e))
+                                }
+                            };
+                            meta_env.map_variable("content".to_string(), false, content_val);
+                        }
+
+                        let stmt = meta_fn(&mut meta_env);
+                        if let Statement::Return(expr) = stmt {
+                            Ok(ExpressionResult::Value(*expr))
+                        } else {
+                            Err("[Runtime Error] open builtin did not return a value".into())
+                        }
+                    }
+
+                    _ => Err(format!("Function {} not found", name)),
+                }
+            } else {
+                Err(format!("Function {} not found", name))
+            }
+        }
     }
 }
 
diff --git a/src/interpreter/statement_execute.rs b/src/interpreter/statement_execute.rs
@@ -479,6 +479,12 @@ pub fn execute(stmt: Statement, env: &Environment<Expression>) -> Result<Computa
             Ok(Computation::Continue(new_env))
         }
 
+        // Executa uma expressão apenas por seus efeitos colaterais (por exemplo, print(x)).
+        Statement::ExprStmt(exp) => match eval(*exp, &new_env)? {
+            ExpressionResult::Value(_) => Ok(Computation::Continue(new_env)),
+            ExpressionResult::Propagate(expr) => Ok(Computation::PropagateError(expr, new_env)),
+        },
+
         Statement::MetaStmt(ref name) => {
             let table = get_metabuiltins_table();
             if let Some(f) = table.get(name) {
diff --git a/src/ir/ast.rs b/src/ir/ast.rs
@@ -152,5 +152,7 @@ pub enum Statement {
     FuncDef(Function),
     Return(Box<Expression>),
     TypeDeclaration(Name, Vec<ValueConstructor>),
+    /// Avalia uma expressão apenas por seus efeitos colaterais (ex: chamada de função).
+    ExprStmt(Box<Expression>),
     MetaStmt(String),
 }
diff --git a/src/parser/keywords.rs b/src/parser/keywords.rs
@@ -23,7 +23,4 @@ pub const KEYWORDS: &[&str] = &[
     "True",
     "False",
     "test",
-    "print",
-    "input",
-    "open",
 ];
diff --git a/src/pretty_print/pretty_statements.rs b/src/pretty_print/pretty_statements.rs
@@ -205,6 +205,9 @@ impl ToDoc for Statement {
                 )
             }
 
+            // Statement de expressão: apenas imprime a expressão seguida de ';'
+            Statement::ExprStmt(expr) => concat(expr.to_doc(), text(";")),
+
             // Metabuiltin statement: just emit its name as a standalone command.
             Statement::MetaStmt(name) => concat(text("meta "), text(name.clone())),
 
diff --git a/src/type_checker/expression_type_checker.rs b/src/type_checker/expression_type_checker.rs
@@ -19,6 +19,7 @@ pub fn check_expr(exp: Expression, env: &Environment<Type>) -> Result<Type, Erro
         Expression::Or(l, r) => check_bin_boolean_expression(*l, *r, env),
         Expression::Not(e) => check_not_expression(*e, env),
         Expression::EQ(l, r) => check_bin_relational_expression(*l, *r, env),
+        Expression::NEQ(l, r) => check_bin_relational_expression(*l, *r, env),
         Expression::GT(l, r) => check_bin_relational_expression(*l, *r, env),
         Expression::LT(l, r) => check_bin_relational_expression(*l, *r, env),
         Expression::GTE(l, r) => check_bin_relational_expression(*l, *r, env),
@@ -33,9 +34,46 @@ pub fn check_expr(exp: Expression, env: &Environment<Type>) -> Result<Type, Erro
         Expression::Unwrap(e) => check_unwrap_type(*e, env),
         Expression::Propagate(e) => check_propagate_type(*e, env),
         Expression::ListValue(elements) => check_list_value(&elements, env),
+        Expression::Tuple(elements) => check_tuple_value(&elements, env),
+        Expression::FuncCall(name, args) => check_function_call(name, args, env),
         Expression::Constructor(name, args) => check_adt_constructor(name, args, env),
+    }
+}
 
-        _ => Err("not implemented yet.".to_string()),
+fn check_function_call(
+    name: Name,
+    args: Vec<Expression>,
+    env: &Environment<Type>,
+) -> Result<Type, ErrorMessage> {
+    match env.lookup_function(&name) {
+        Some(function) => {
+            // Checa número de argumentos
+            if args.len() != function.params.len() {
+                return Err(format!(
+                    "[Type Error] Function '{}' expects {} arguments, but got {}.",
+                    name,
+                    function.params.len(),
+                    args.len()
+                ));
+            }
+
+            // Checa tipos de cada argumento contra o parâmetro correspondente
+            for (arg_expr, param) in args.into_iter().zip(function.params.iter()) {
+                let arg_type = check_expr(arg_expr, env)?;
+                let param_type = param.argument_type.clone();
+
+                // Permite TAny em qualquer lado como curinga
+                if param_type != Type::TAny && arg_type != Type::TAny && arg_type != param_type {
+                    return Err(format!(
+                        "[Type Error] In call to function '{}', argument '{}' expected type '{:?}', found '{:?}'.",
+                        name, param.argument_name, param_type, arg_type
+                    ));
+                }
+            }
+
+            Ok(function.kind.clone())
+        }
+        None => Err(format!("[Type Error] Function '{}' is not defined.", name)),
     }
 }
 
@@ -184,6 +222,18 @@ fn check_list_value(
     Ok(Type::TList(Box::new(first_type)))
 }
 
+fn check_tuple_value(
+    elements: &[Expression],
+    env: &Environment<Type>,
+) -> Result<Type, ErrorMessage> {
+    let mut types = Vec::with_capacity(elements.len());
+    for element in elements {
+        let element_type = check_expr(element.clone(), env)?;
+        types.push(element_type);
+    }
+    Ok(Type::TTuple(types))
+}
+
 fn check_adt_constructor(
     name: Name,
     args: Vec<Box<Expression>>,
diff --git a/src/type_checker/statement_type_checker.rs b/src/type_checker/statement_type_checker.rs
@@ -16,20 +16,54 @@ pub fn check_stmt(
         Statement::IfThenElse(cond, stmt_then, stmt_else_opt) => {
             check_if_then_else_stmt(cond, stmt_then, stmt_else_opt, env)
         }
+        Statement::IfChain {
+            branches,
+            else_branch,
+        } => check_if_chain_stmt(branches, else_branch, env),
         Statement::While(cond, stmt) => check_while_stmt(cond, stmt, env),
         Statement::For(var, expr, stmt) => check_for_stmt(var, expr, stmt, env),
         Statement::FuncDef(function) => check_func_def_stmt(function, env),
         Statement::TypeDeclaration(name, cons) => check_adt_declarations_stmt(name, cons, env),
         Statement::Return(exp) => check_return_stmt(exp, env),
 
+        // Blocos no nível de statement: empilham escopo e checam internamente.
+        Statement::Block(stmts) => {
+            let mut block_env = env.clone();
+            block_env.push();
+
+            for s in stmts {
+                block_env = check_stmt(s, &block_env)?;
+            }
+            block_env.pop();
+            Ok(block_env)
+        }
+
         Statement::Assert(expr1, errmsg) => check_assert(expr1, errmsg, env),
         Statement::AssertTrue(expr1, errmsg) => check_assert_true(expr1, errmsg, env),
         Statement::AssertFalse(expr1, errmsg) => check_assert_false(expr1, errmsg, env),
         Statement::AssertEQ(lhs, rhs, errmsg) => check_assert_eq(lhs, rhs, errmsg, env),
         Statement::AssertNEQ(lhs, rhs, errmsg) => check_assert_neq(lhs, rhs, errmsg, env),
         Statement::TestDef(function) => check_test_function_stmt(function, env),
 
-        _ => Err("Not implemented yet".to_string()),
+        // Statement de expressão: só garante que a expressão é bem-tipada.
+        Statement::ExprStmt(exp) => {
+            let _ = check_expr(*exp, env)?;
+            Ok(env.clone())
+        }
+
+        // Metabuiltins são tratados apenas em tempo de execução; do ponto de vista
+        // de tipos, não alteram o ambiente.
+        Statement::MetaStmt(_) => Ok(env.clone()),
+
+        // AssertFails carrega apenas uma mensagem literal; não há expressão a checar.
+        Statement::AssertFails(_) => Ok(env.clone()),
+
+        // ModTestDef agrupa um statement de teste por módulo; checamos o corpo,
+        // mas não expomos nada novo no ambiente global.
+        Statement::ModTestDef(_, stmt) => {
+            let _ = check_stmt(*stmt, env)?;
+            Ok(env.clone())
+        }
     }
 }
 
@@ -152,6 +186,45 @@ fn check_if_then_else_stmt(
     Ok(new_env)
 }
 
+fn check_if_chain_stmt(
+    branches: Vec<(Box<Expression>, Box<Statement>)>,
+    else_branch: Option<Box<Statement>>,
+    env: &Environment<Type>,
+) -> Result<Environment<Type>, ErrorMessage> {
+    if branches.is_empty() {
+        return Err("[Type Error] if-chain must have at least one branch.".to_string());
+    }
+
+    let mut branch_envs: Vec<Environment<Type>> = Vec::new();
+
+    for (cond, stmt) in branches {
+        let mut local_env = env.clone();
+        let cond_type = check_expr(*cond, &local_env)?;
+        if cond_type != Type::TBool {
+            return Err(
+                "[Type Error] a condition in an 'if/elif' branch must be of type boolean."
+                    .to_string(),
+            );
+        }
+        local_env = check_stmt(*stmt, &local_env)?;
+        branch_envs.push(local_env);
+    }
+
+    if let Some(stmt) = else_branch {
+        let else_env = check_stmt(*stmt, env)?;
+        branch_envs.push(else_env);
+    }
+
+    // Mescla progressivamente todos os ambientes resultantes,
+    // começando do ambiente original.
+    let mut acc_env = env.clone();
+    for branch_env in branch_envs {
+        acc_env = merge_environments(&acc_env, &branch_env)?;
+    }
+
+    Ok(acc_env)
+}
+
 fn check_while_stmt(
     cond: Box<Expression>,
     stmt: Box<Statement>,

Original file line number	Diff line number	Diff line change
`@@ -152,5 +152,7 @@ pub enum Statement {`
`152`	`152`	`FuncDef(Function),`
`153`	`153`	`Return(Box<Expression>),`
`154`	`154`	`TypeDeclaration(Name, Vec<ValueConstructor>),`
	`155`	`+ /// Avalia uma expressão apenas por seus efeitos colaterais (ex: chamada de função).`
	`156`	`+ ExprStmt(Box<Expression>),`
`155`	`157`	`MetaStmt(String),`
`156`	`158`	`}`
Original file line number	Diff line number	Diff line change
`@@ -205,6 +205,9 @@ impl ToDoc for Statement {`
`205`	`205`	`)`
`206`	`206`	`}`
`207`	`207`
	`208`	`+ // Statement de expressão: apenas imprime a expressão seguida de ';'`
	`209`	`+ Statement::ExprStmt(expr) => concat(expr.to_doc(), text(";")),`
	`210`	`+`
`208`	`211`	`// Metabuiltin statement: just emit its name as a standalone command.`
`209`	`212`	`Statement::MetaStmt(name) => concat(text("meta "), text(name.clone())),`
`210`	`213`