Add Method Chaining (#216)

* Añadir el método de encadenamiento

* Implementing http

* v0.1.4-pre-beta

Author: LunaStev

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wavec"
-version = "0.1.4-pre-beta-nightly-2025-07-16"
+version = "0.1.4-pre-beta"
 edition = "2021"
 
 # [target.x86_64-apple-darwin]

front/lexer/src/lexer/lexer.rs

@@ -509,7 +509,7 @@ impl<'a> Lexer<'a> {
                     line: self.line,
                 }
             },
-            'a'..='z' | 'A'..='Z' => {
+            'a'..='z' | 'A'..='Z' | '_' => {
                 let identifier = self.identifier();
                 match identifier.as_str() {
                     "fun" => {

front/parser/src/parser/ast.rs

@@ -78,6 +78,11 @@ pub enum Expression {
         name: String,
         args: Vec<Expression>,
     },
+    MethodCall {
+        object: Box<Expression>,
+        name: String,
+        args: Vec<Expression>,
+    },
     Literal(Literal),
     Variable(String),
     Deref(Box<Expression>),

front/parser/src/parser/format.rs

@@ -213,7 +213,7 @@ where
 {
     let token = tokens.peek()?.clone();
 
-    match &token.token_type {
+    let mut expr = match &token.token_type {
         TokenType::Number(value) => {
             tokens.next();
             Some(Expression::Literal(Literal::Number(*value)))
@@ -455,7 +455,71 @@ where
                 }
             }
         }
+    };
+
+    loop {
+        match tokens.peek().map(|t| &t.token_type) {
+            Some(TokenType::Dot) => {
+                tokens.next();
+
+                let name = if let Some(Token { token_type: TokenType::Identifier(name), .. }) = tokens.next() {
+                    name.clone()
+                } else {
+                    println!("Error: Expected identifier after Dot");
+                    return None;
+                };
+
+                if tokens.peek().map_or(true, |t| t.token_type != TokenType::Lparen) {
+                    println!("Error: Expected '(' for method call");
+                    return None;
+                }
+                tokens.next();
+
+                let mut args = vec![];
+                if tokens.peek().map_or(false, |t| t.token_type != TokenType::Rparen) {
+                    loop {
+                        let arg = parse_expression(tokens)?;
+                        args.push(arg);
+
+                        if let Some(Token { token_type: TokenType::Comma, .. }) = tokens.peek() {
+                            tokens.next();
+                        } else {
+                            break;
+                        }
+                    }
+                }
+
+                if tokens.peek().map_or(true, |t| t.token_type != TokenType::Rparen) {
+                    println!("Error: Expected ')' after method call arguments");
+                    return None;
+                }
+                tokens.next();
+
+                expr = Some(Expression::MethodCall {
+                    object: Box::new(expr?),
+                    name,
+                    args,
+                });
+            }
+            Some(TokenType::Lbrack) => {
+                tokens.next();
+                let index_expr = parse_expression(tokens)?;
+                if tokens.peek().map_or(true, |t| t.token_type != TokenType::Rbrack) {
+                    println!("Error: Expected ']' after index");
+                    return None;
+                }
+                tokens.next();
+                expr = Some(Expression::IndexAccess {
+                    target: Box::new(expr?),
+                    index: Box::new(index_expr),
+                });
+            }
+            _ => {
+                break;
+            }
+        }
     }
+    Some(expr?)
 }
 
 pub fn parse_parenthesized_expression<'a, T>(tokens: &mut Peekable<T>) -> Option<Expression>

llvm_temporary/src/llvm_temporary/expression.rs

@@ -175,6 +175,43 @@ pub fn generate_expression_ir<'ctx>(
             }
         }
 
+        Expression::MethodCall { object, name, args } => {
+            let function = module
+                .get_function(name)
+                .unwrap_or_else(|| panic!("Function '{}' not found as a global function", name));
+
+            let function_type = function.get_type();
+            let param_types: Vec<BasicTypeEnum> = function_type
+                .get_param_types()
+                .iter()
+                .map(|t| (*t).into())
+                .collect();
+
+            let object_expected_type = param_types.get(0).copied();
+            let object_val = generate_expression_ir(context, builder, object, variables, module, object_expected_type);
+
+            let mut compiled_args: Vec<inkwell::values::BasicMetadataValueEnum<'ctx>> = vec![object_val.into()];
+
+            for (i, arg) in args.iter().enumerate() {
+                let expected = param_types.get(i + 1).copied();
+                let val = generate_expression_ir(context, builder, arg, variables, module, expected);
+
+                compiled_args.push(val.into());
+            }
+
+            let call_site = builder.build_call(function, &compiled_args, &format!("call_{}", name)).unwrap();
+
+            if function_type.get_return_type().is_some() {
+                if let Some(ret_val) = call_site.try_as_basic_value().left() {
+                    ret_val
+                } else {
+                    panic!("Method '{}' should return a value but didn't", name);
+                }
+            } else {
+                context.i32_type().const_zero().as_basic_value_enum()
+            }
+        }
+
         Expression::AssignOperation { target, operator, value } => {
             let ptr = generate_address_ir(context, builder, target, variables, module);
 

llvm_temporary/src/llvm_temporary/statement.rs

@@ -183,7 +183,7 @@ pub fn generate_statement_ir<'ctx>(
                         let val = generate_expression_ir(context, builder, init, variables, module, Some(llvm_type));
                         builder.build_store(alloca, val).unwrap();
                     }
-                    (Expression::FunctionCall { .. }, _) => {
+                    (Expression::FunctionCall { .. } | Expression::MethodCall { .. }, _) => {
                         let val = generate_expression_ir(context, builder, init, variables, module, Some(llvm_type));
                         builder.build_store(alloca, val).unwrap();
                     }

test/test55.wave

@@ -0,0 +1,36 @@
+fun len(s: str) -> i32 {
+    var count: i32 = 0;
+    while (s[count] != 0) {
+        count += 1;
+    }
+    return count;
+}
+
+// num.add(val) -> add(num, val)
+fun add(self: i32, value: i32) -> i32 {
+    return self + value;
+}
+
+fun subtract(self: i32, value: i32) -> i32 {
+    return self - value;
+}
+
+fun main() {
+    println("--- Test 55: Method Chaining ---");
+
+    println("\n[1. Simple Method Call]");
+    var my_string: str = "Hello from Wave's Chaining API!";
+    println("Testing string: '{}'", my_string);
+
+    var length: i32 = my_string.len();
+    println("Result of my_string.len(): {}", length);
+
+    println("\n[2. Chained Method Calls]");
+    var num: i32 = 10;
+    println("Initial number: {}", num);
+
+    var chained_result: i32 = num.add(5).subtract(3);
+    println("Result of num.add(5).subtract(3): {}", chained_result);
+
+    println("\n--- Test 55 Finished ---");
+}

test/test56.wave

@@ -0,0 +1,126 @@
+fun syscall1(id: i64) -> i64 {
+    var ret_val: i64;
+    asm {
+        "syscall"
+        in("rax") id
+        out("rax") ret_val
+    }
+    return ret_val;
+}
+
+fun syscall2(id: i64, arg1: i64) -> i64 {
+    var ret_val: i64;
+    asm {
+        "syscall"
+        in("rax") id
+        in("rdi") arg1
+        out("rax") ret_val
+    }
+    return ret_val;
+}
+
+fun syscall3(id: i64, arg1: i64, arg2: i64) -> i64 {
+    var ret_val: i64;
+    asm {
+        "syscall"
+        in("rax") id
+        in("rdi") arg1
+        in("rsi") arg2
+        out("rax") ret_val
+    }
+    return ret_val;
+}
+
+fun syscall4(id: i64, arg1: i64, arg2: i64, arg3: i64) -> i64 {
+    var ret_val: i64;
+    asm {
+        "syscall"
+        in("rax") id
+        in("rdi") arg1
+        in("rsi") arg2
+        in("rdx") arg3
+        out("rax") ret_val
+    }
+    return ret_val;
+}
+
+fun _socket_create() -> i32 {
+    return syscall4(41, 2, 1, 0);
+}
+
+fun _socket_bind(sockfd: i32, ip_addr: i32, port: i16) -> i32 {
+    asm {
+        out("rax") result
+        in("rdi") sockfd
+    }
+    return result;
+}
+
+fun _socket_listen(sockfd: i32, backlog: i32) -> i32 {
+    return syscall3(50, sockfd, backlog);
+}
+
+fun _socket_close(sockfd: i32) {
+    syscall2(3, sockfd);
+}
+
+fun new_server(ip_str: str, port: i16) -> ptr<i32> {
+    var sockfd: i32 = _socket_create();
+    if (sockfd < 0) {
+        println("Error: Failed to create socket.");
+        return 0;
+    }
+
+    if (_socket_bind(sockfd, 0, port) < 0) {
+        println("Error: Failed to bind socket.");
+        _socket_close(sockfd);
+        return 0;
+    }
+
+    return sockfd;
+}
+
+fun listen(server_fd: i32, backlog: i32) -> i32 {
+    if (_socket_listen(server_fd, backlog) < 0) {
+        println("Error: Failed to listen on socket.");
+        return -1;
+    }
+    println("Server is listening...");
+    return server_fd;
+}
+
+fun start(server_fd: i32) {
+    println("Server accepting connections...");
+
+    while (true) {
+        var client_fd: i32 = syscall3(43, server_fd, 0);
+
+        if (client_fd < 0) {
+            println("Error: Failed to accept connection.");
+            continue;
+        }
+
+        println("Client connected! fd: {}", client_fd);
+
+        var response: str = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nWelcome to the Wave HTTP Server!";
+
+        syscall4(1, client_fd, response, 82);
+
+        _socket_close(client_fd);
+        println("Client disconnected.");
+    }
+}
+
+
+fun main() {
+    println("--- Wave HTTP Server Application ---");
+
+    var server_instance: i32 = new_server("0.0.0.0", 8080)
+                                 .listen(10);
+
+    if (server_instance >= 0) {
+        server_instance.start();
+    } else {
+        println("Server failed to start.");
+    }
+}