feat: implement input() statement and lvalue generation (#259)

Add support for reading user input using `scanf` and reorganize
expression handling to support L-value generation.

Changes:
- AST/Parser:
  - Add `StatementNode::Input` variant.
  - Implement `parse_input` to handle `input("fmt", var)` syntax.
  - Enforce `input()` format string validation (placeholder count matches args).
- Expression Codegen Refactor:
  - Split `expression.rs` into `mod.rs`, `rvalue.rs`, and `lvalue.rs`.
  - Move existing R-value generation to `rvalue.rs`.
  - Implement `generate_lvalue_ir` in `lvalue.rs` to support address generation for:
    - Variables, Dereferences, AddressOf (`&`).
    - Array Indexing (`arr[i]`), Struct Field Access (`obj.field`).
    - Handles nested expressions and ensures type correctness.
- LLVM Codegen:
  - Implement `wave_format_to_scanf` to convert Wave format strings to C-style `scanf` formats.
  - Generate IR for `input()`:
    - Calls `scanf` with generated format string and variable addresses.
    - Validates `scanf` return value (matches expected argument count).
    - Exits program with code 1 on input failure.
- Runner:
  - Update `run_wave_file` to use `Stdio::inherit()` for stdin/stdout/stderr.
  - Allows interactive input during execution.
- Tests:
  - Update `test74.wave` to demonstrate `input()` usage.

This enables interactive console applications in Wave by providing
standard input capabilities.

Signed-off-by: LunaStev <luna@lunastev.org>

Author: LunaStev

front/parser/src/parser/ast.rs

@@ -198,6 +198,10 @@ pub enum StatementNode {
         format: String,
         args: Vec<Expression>,
     },
+    Input {
+        format: String,
+        args: Vec<Expression>,
+    },
     Variable(String),
     If {
         condition: Expression,

front/parser/src/parser/parser.rs

@@ -281,6 +281,19 @@ pub fn extract_body(tokens: &mut Peekable<Iter<Token>>) -> Option<Vec<ASTNode>>
                 }
                 body.push(node);
             }
+            TokenType::Input => {
+                tokens.next(); // consume 'input'
+                let node = parse_input(tokens)?;
+                // Added semicolon handling
+                if let Some(Token {
+                                token_type: TokenType::SemiColon,
+                                ..
+                            }) = tokens.peek()
+                {
+                    tokens.next();
+                }
+                body.push(node);
+            }
             TokenType::If => {
                 tokens.next();
                 body.push(parse_if(tokens)?);
@@ -956,6 +969,71 @@ fn parse_print(tokens: &mut Peekable<Iter<Token>>) -> Option<ASTNode> {
     }))
 }
 
+fn parse_input(tokens: &mut Peekable<Iter<Token>>) -> Option<ASTNode> {
+    if tokens.peek()?.token_type != TokenType::Lparen {
+        println!("Error: Expected '(' after 'println'");
+        return None;
+    }
+    tokens.next(); // Consume '('
+
+    let content = if let Some(Token {
+                                  token_type: TokenType::String(content),
+                                  ..
+                              }) = tokens.next()
+    {
+        content.clone() // Need clone() because it is String
+    } else {
+        println!("Error: Expected string literal in 'input'");
+        return None;
+    };
+
+    let placeholder_count = Regex::new(r"\{[^}]*\}")
+        .unwrap()
+        .find_iter(&content)
+        .count();
+
+    let mut args = Vec::new();
+    while let Some(Token {
+                       token_type: TokenType::Comma,
+                       ..
+                   }) = tokens.peek()
+    {
+        tokens.next(); // Consume ','
+        if let Some(expr) = parse_expression(tokens) {
+            args.push(expr);
+        } else {
+            println!("Error: Failed to parse expression in 'println'");
+            return None;
+        }
+    }
+
+    if tokens.peek()?.token_type != TokenType::Rparen {
+        println!("Error: Expected closing ')'");
+        return None;
+    }
+    tokens.next(); // Consume ')'
+
+    if tokens.peek().map(|t| &t.token_type) != Some(&TokenType::SemiColon) {
+        println!("Expected ';' after expression");
+        return None;
+    }
+    tokens.next();
+
+    if placeholder_count != args.len() {
+        println!(
+            "Error: Expected {} arguments, found {}",
+            placeholder_count,
+            args.len()
+        );
+        return None;
+    }
+
+    Some(ASTNode::Statement(StatementNode::Input {
+        format: content,
+        args,
+    }))
+}
+
 fn skip_whitespace(tokens: &mut Peekable<Iter<Token>>) {
     while let Some(token) = tokens.peek() {
         if token.token_type == TokenType::Whitespace {

llvm_temporary/src/llvm_temporary/expression/lvalue.rs

@@ -0,0 +1,208 @@
+use inkwell::{
+    builder::Builder,
+    context::Context,
+    module::Module,
+    types::StructType,
+    values::{BasicValueEnum, PointerValue},
+    AddressSpace,
+};
+use std::collections::HashMap;
+use parser::ast::Expression;
+use crate::llvm_temporary::expression::rvalue::generate_expression_ir;
+use crate::llvm_temporary::llvm_codegen::VariableInfo;
+
+pub fn generate_lvalue_ir<'ctx>(
+    context: &'ctx Context,
+    builder: &'ctx Builder<'ctx>,
+    expr: &Expression,
+    variables: &mut HashMap<String, VariableInfo<'ctx>>,
+    module: &'ctx Module<'ctx>,
+    global_consts: &HashMap<String, BasicValueEnum<'ctx>>,
+    struct_types: &HashMap<String, StructType<'ctx>>,
+    struct_field_indices: &HashMap<String, HashMap<String, u32>>,
+) -> PointerValue<'ctx> {
+    match expr {
+        Expression::Variable(name) => {
+            if global_consts.contains_key(name) {
+                panic!("Cannot use constant '{}' as lvalue", name);
+            }
+
+            let info = variables
+                .get(name)
+                .unwrap_or_else(|| panic!("Undefined variable '{}'", name));
+
+            info.ptr
+        }
+
+        Expression::Grouped(inner) => generate_lvalue_ir(
+            context,
+            builder,
+            inner,
+            variables,
+            module,
+            global_consts,
+            struct_types,
+            struct_field_indices,
+        ),
+
+        Expression::Deref(inner) => {
+            let v = generate_expression_ir(
+                context,
+                builder,
+                inner,
+                variables,
+                module,
+                None,
+                global_consts,
+                struct_types,
+                struct_field_indices,
+            );
+
+            match v {
+                BasicValueEnum::PointerValue(p) => p,
+                _ => panic!("Deref target is not a pointer: {:?}", inner),
+            }
+        }
+
+        Expression::AddressOf(inner) => generate_lvalue_ir(
+            context,
+            builder,
+            inner,
+            variables,
+            module,
+            global_consts,
+            struct_types,
+            struct_field_indices,
+        ),
+
+        Expression::IndexAccess { target, index } => {
+            let idx_val = generate_expression_ir(
+                context,
+                builder,
+                index,
+                variables,
+                module,
+                None,
+                global_consts,
+                struct_types,
+                struct_field_indices,
+            );
+
+            let mut idx = match idx_val {
+                BasicValueEnum::IntValue(iv) => iv,
+                _ => panic!("Index is not an integer: {:?}", index),
+            };
+
+            if idx.get_type().get_bit_width() != 32 {
+                idx = builder
+                    .build_int_cast(idx, context.i32_type(), "idx_i32")
+                    .unwrap();
+            }
+
+            let base_ptr: PointerValue<'ctx> = match &**target {
+                Expression::Variable(_)
+                | Expression::Deref(_)
+                | Expression::AddressOf(_)
+                | Expression::IndexAccess { .. }
+                | Expression::FieldAccess { .. }
+                | Expression::Grouped(_) => {
+                    let lv = generate_lvalue_ir(
+                        context,
+                        builder,
+                        target,
+                        variables,
+                        module,
+                        global_consts,
+                        struct_types,
+                        struct_field_indices,
+                    );
+
+                    let elem_ty = lv.get_type().get_element_type();
+                    if elem_ty.is_pointer_type() {
+                        let loaded = builder.build_load(lv, "load_index_base").unwrap();
+                        match loaded {
+                            BasicValueEnum::PointerValue(p) => p,
+                            _ => panic!("Index base is not a pointer"),
+                        }
+                    } else {
+                        lv
+                    }
+                }
+                _ => {
+                    let v = generate_expression_ir(
+                        context,
+                        builder,
+                        target,
+                        variables,
+                        module,
+                        None,
+                        global_consts,
+                        struct_types,
+                        struct_field_indices,
+                    );
+                    match v {
+                        BasicValueEnum::PointerValue(p) => p,
+                        _ => panic!("Index target is not a pointer/array: {:?}", target),
+                    }
+                }
+            };
+
+            let zero = context.i32_type().const_zero();
+            let base_elem_ty = base_ptr.get_type().get_element_type();
+
+            if base_elem_ty.is_array_type() {
+                unsafe { builder.build_gep(base_ptr, &[zero, idx], "array_elem_ptr").unwrap() }
+            } else {
+                unsafe { builder.build_gep(base_ptr, &[idx], "ptr_elem_ptr").unwrap() }
+            }
+        }
+
+        Expression::FieldAccess { object, field } => {
+            let mut obj_ptr = generate_lvalue_ir(
+                context,
+                builder,
+                object,
+                variables,
+                module,
+                global_consts,
+                struct_types,
+                struct_field_indices,
+            );
+
+            let obj_elem_ty = obj_ptr.get_type().get_element_type();
+            if obj_elem_ty.is_pointer_type() {
+                let loaded = builder.build_load(obj_ptr, "load_struct_ptr").unwrap();
+                obj_ptr = match loaded {
+                    BasicValueEnum::PointerValue(p) => p,
+                    _ => panic!("FieldAccess base is not a pointer"),
+                };
+            }
+
+            let struct_ty = obj_ptr
+                .get_type()
+                .get_element_type()
+                .into_struct_type();
+
+            let raw_name = struct_ty
+                .get_name()
+                .and_then(|c| c.to_str().ok())
+                .unwrap_or_else(|| panic!("Unnamed struct type; cannot resolve field '{}'", field));
+
+            let struct_name = raw_name.strip_prefix("struct.").unwrap_or(raw_name);
+
+            let field_index = struct_field_indices
+                .get(struct_name)
+                .and_then(|m| m.get(field))
+                .copied()
+                .unwrap_or_else(|| panic!("Unknown field '{}.{}'", struct_name, field));
+
+            builder
+                .build_struct_gep(obj_ptr, field_index, "field_ptr")
+                .unwrap()
+        }
+
+        _ => {
+            panic!("Expression is not an lvalue (not assignable): {:?}", expr);
+        }
+    }
+}

llvm_temporary/src/llvm_temporary/expression/mod.rs

@@ -0,0 +1,2 @@
+pub mod lvalue;
+pub mod rvalue;

…mporary/src/llvm_temporary/expression.rs …/src/llvm_temporary/expression/rvalue.rsllvm_temporary/src/llvm_temporary/expression.rs renamed to llvm_temporary/src/llvm_temporary/expression/rvalue.rs llvm_temporary/src/llvm_temporary/expression.rs renamed to llvm_temporary/src/llvm_temporary/expression/rvalue.rs

@@ -5,7 +5,7 @@ use inkwell::{AddressSpace, OptimizationLevel};
 use parser::ast::{ASTNode, Expression, FunctionNode, Literal, Mutability, VariableNode, WaveType};
 
 use crate::llvm_temporary::statement::generate_statement_ir;
-use inkwell::types::{BasicMetadataTypeEnum, BasicType, BasicTypeEnum};
+use inkwell::types::{AnyTypeEnum, BasicMetadataTypeEnum, BasicType, BasicTypeEnum};
 use lexer::token::TokenType;
 use std::collections::HashMap;
 use std::hash::Hash;
@@ -239,6 +239,63 @@ pub fn wave_format_to_c(format: &str, arg_types: &[BasicTypeEnum]) -> String {
     result
 }
 
+pub fn wave_format_to_scanf(format: &str, arg_types: &[AnyTypeEnum]) -> String {
+    let mut result = String::new();
+    let mut chars = format.chars().peekable();
+    let mut arg_index = 0;
+
+    while let Some(c) = chars.next() {
+        if c == '{' {
+            if let Some('}') = chars.peek() {
+                chars.next(); // consume '}'
+
+                let ty = arg_types
+                    .get(arg_index)
+                    .unwrap_or_else(|| panic!("Missing argument for format"));
+
+                let fmt = match ty {
+                    AnyTypeEnum::IntType(_) => "%d",
+                    AnyTypeEnum::FloatType(_) => "%f",
+
+                    AnyTypeEnum::PointerType(ptr_ty) => {
+                        let elem = ptr_ty.get_element_type();
+                        match elem {
+                            AnyTypeEnum::IntType(it)
+                            if it.get_bit_width() == 8 =>
+                                {
+                                    "%s" // char*
+                                }
+                            _ => {
+                                panic!("Unsupported pointer type for input");
+                            }
+                        }
+                    }
+
+                    AnyTypeEnum::StructType(_) => {
+                        panic!("Cannot input into struct directly");
+                    }
+
+                    AnyTypeEnum::ArrayType(_) => {
+                        panic!("Cannot input into array directly");
+                    }
+
+                    _ => {
+                        panic!("Unsupported type for input");
+                    }
+                };
+
+                result.push_str(fmt);
+                arg_index += 1;
+                continue;
+            }
+        }
+
+        result.push(c);
+    }
+
+    result
+}
+
 pub fn wave_type_to_llvm_type<'ctx>(
     context: &'ctx Context,
     wave_type: &WaveType,

llvm_temporary/src/llvm_temporary/llvm_codegen.rs

@@ -17,7 +17,7 @@
     clippy::new_without_default
 )]
 
-mod expression;
+pub mod expression;
 pub mod llvm_backend;
 pub mod llvm_codegen;
 mod statement;