oop classes start ik value::instance no existy

Author: cyteon

lang/examples/oop.modu

@@ -0,0 +1,33 @@
+class Counter {
+    fn new(start) {
+        self.value = start;
+    }
+
+    fn increment() {
+        self.value += 1;
+    }
+
+    fn decrement() {
+        self.value -= 1;
+    }
+    
+    fn value() {
+        return self.value;
+    }
+
+    fn reset() {
+        self.value = 0;
+    }
+}
+
+let counter = Counter(1);
+counter.increment();
+
+print(counter.value);
+
+counter.decrement();
+print(counter.value());
+
+counter.reset();
+counter.decrement();
+print(counter.value);

lang/src/ast.rs

@@ -121,5 +121,10 @@ pub enum Expr {
     NotIn(Box<Spanned<Expr>>, Box<Spanned<Expr>>),
     And(Box<Spanned<Expr>>, Box<Spanned<Expr>>),
     Or(Box<Spanned<Expr>>, Box<Spanned<Expr>>),
-    Not(Box<Spanned<Expr>>)
+    Not(Box<Spanned<Expr>>),
+
+    Class {
+        name: String,
+        methods: Vec<Spanned<Expr>>,
+    }
 }

lang/src/compiler/compiler.rs

@@ -1,4 +1,5 @@
 use chumsky::span::SimpleSpan;
+use std::collections::HashMap;
 
 use crate::vm::chunk::Chunk;
 use crate::vm::instruction::Instruction;
@@ -559,6 +560,54 @@ impl Compiler {
             Expr::Import { name, alias } => {
                 self.emit(Instruction::Import { path: name.clone(), alias: alias.clone() }, span);
             }
+
+            Expr::Class { name, methods } => {
+                let mut methods_map = HashMap::new();
+
+                for f in methods {
+                    if let Expr::Function { name: method_name, args, body } = &f.node {
+                        let chunk_id = self.chunks.len() + self.offset;
+                        self.chunks.push(Chunk::new(&format!("{}::{}", name, method_name)));
+                        
+                        let saved_chunk = self.current_chunk;
+                        self.current_chunk = chunk_id;
+
+                        let saved_scope = self.scope.enter_function();
+                        self.scope.define_local("self");
+
+                        for arg in args {
+                            self.scope.define_local(arg);
+                        }
+
+                        self.compile_expr(*body.clone())?;
+
+                        if method_name == "new" {
+                            self.emit(Instruction::LoadLocal(0), span);
+                        } else {
+                            self.emit(Instruction::PushNull, span);
+                        }
+
+                        self.emit(Instruction::Return, span);
+
+                        let locals_count = self.scope.exit_function(saved_scope);
+                        self.chunks[chunk_id].locals_count = locals_count;
+                        self.current_chunk = saved_chunk;
+
+                        methods_map.insert(
+                            method_name.clone(), 
+                            Value::Function { chunk_id, arity: args.len() }
+                        );
+                    } else {
+                        return Err("class body can only contain functions".to_string());
+                    }
+                }
+
+                let class_value = Value::Class { name: name.clone(), methods: methods_map };
+                let index = self.add_constant(class_value);
+
+                self.emit(Instruction::Push(index), span);
+                self.store_variable(name, span);
+            }
         }
 
         Ok(())

lang/src/lexer.rs

@@ -92,6 +92,9 @@ pub enum Token {
     #[token("fn")]
     Function,
 
+    #[token("class")]
+    Class,
+
     #[token("import")]
     Import,
 

lang/src/parser.rs

@@ -118,7 +118,11 @@ fn parser<'src>() -> impl Parser<
                     },
 
                     Postfix::Call(args) => SpannedExpr {
-                        span: (obj.span.start..(obj.span.end + 2)).into(), // include ()
+                        span: (obj.span.start..(
+                            obj.span.end + 2 
+                            + args.iter().map(|arg| arg.span.end - arg.span.start).sum::<usize>() 
+                            + (args.len().saturating_sub(1) * 2))
+                        ).into(), // so it marks (..) in call(..)
                         node: Expr::Call {
                             callee: Box::new(obj.clone()),
                             args,
@@ -370,6 +374,19 @@ fn parser<'src>() -> impl Parser<
             })
             .labelled("function declaration");
 
+        let class_stmt = select! { (Token::Class, span) => span }
+            .then(select! { (Token::Identifier(name), _) => name }.labelled("class name"))
+            .then(
+                select! { (Token::LBrace, span) => span }
+                    .then(fn_stmt.clone().repeated().collect::<Vec<_>>())
+                    .then(select! { (Token::RBrace, span) => span })
+            )
+            .map(|((start, name), ((_lbrace, methods), end)): ((Span, String), ((Span, Vec<SpannedExpr>), Span))| SpannedExpr {
+                node: Expr::Class { name, methods },
+                span: Span::from(start.start..end.end),
+            })
+            .labelled("class declaration");
+        
         let infinite_loop_stmt = select! { (Token::Loop, span) => span }
             .then(block.clone().labelled("loop body"))
             .map(|(start, body): (Span, SpannedExpr)| SpannedExpr {
@@ -488,6 +505,7 @@ fn parser<'src>() -> impl Parser<
             let_stmt,
             assign_stmt,
             fn_stmt,
+            class_stmt,
             infinite_loop_stmt,
             for_loop_stmt,
             while_loop_stmt,

lang/src/vm/value.rs

@@ -22,7 +22,12 @@ pub enum Value {
         start: i64,
         end: i64,
         inclusive: bool,
-    }
+    },
+
+    Class {
+        name: String,
+        methods: HashMap<String, Value>,
+    },
 }
 
 #[derive(Clone)]
@@ -197,6 +202,7 @@ impl Value {
             Value::Range { .. } => "range",
             Value::FFILib(_) => "ffi_lib",
             Value::FFIFunc(_, _) => "ffi_function",
+            Value::Class { .. } => "class",
         }
     }
 

lang/src/vm/vm.rs

@@ -274,6 +274,16 @@ impl VM {
                             });
                         }
 
+                        Value::Class { name, methods } => {
+                            let args: Vec<Value> = self.stack.drain(self.stack.len() - argc..).collect();
+                            self.stack.pop();
+
+                            let instance = Value::Instance {
+                                class: name.clone(),
+                                properties: HashMap::new()
+                            };
+                        }
+
                         _ => {
                             return Err(self.runtime_error(format!("{} is not callable", callee.type_name()), span));
                         }